A useful JavaScript question should reveal a mental model, not reward a memorized sentence. Use these groups to practice explaining what happens, why it happens, and how you would verify it.
Language behavior
- How do lexical scope and the scope chain affect a closure?
- When does `this` depend on the call site, and when does it not?
- What practical bugs can implicit coercion introduce?
- How do prototypes support delegation?
- What changes when a module is evaluated more than once?
- How do property descriptors affect an API?
- When would a symbol be useful?
- How do shallow and deep copies differ?
- What makes two values equal under different equality operations?
- How would you explain temporal dead zones?
Async JavaScript and the browser
- Describe one event-loop turn involving a task and queued microtasks.
- How should a UI cancel a request that is no longer relevant?
- What causes an unhandled promise rejection?
- How would you limit concurrency for a batch of requests?
- How can two callers share one in-flight request?
- When is `Promise.allSettled` more useful than `Promise.all`?
- How do you prevent stale responses from replacing fresh data?
- What should happen to a cache entry after the loader rejects?
- How do timers behave in an inactive tab?
- Where can backpressure appear in a frontend system?
Implementation and verification
- Implement debounce with cancellation.
- Implement throttle and explain its leading and trailing behavior.
- Create an event emitter with unsubscribe support.
- Build a request cache with TTL and in-flight deduplication.
- Flatten nested data without mutating the input.
- Write a retry helper with an explicit stopping policy.
- Implement a small task scheduler with a concurrency limit.
- Normalize server data into an entity map.
- Create a memoization helper and describe its invalidation limits.
- Design tests for a function that depends on time.
Senior-level discussion
- Where should runtime validation sit in a typed frontend?
- How do you evolve a shared client API without breaking consumers?
- What should be observable in a request layer?
- How would you investigate a long task in production?
- When is a web worker justified?
- How do bundle boundaries affect runtime behavior?
- How would you design graceful degradation?
- What security assumptions should never live only in client code?
- How do you make error handling consistent without hiding context?
- Which browser constraints would change your architecture?
How to practice the questions
- Answer in three passes: mechanism, concrete example, and tradeoff.
- Write code only after stating the contract and important edge cases.
- Verify one success case, one boundary case, and one failure path.
- Record weak explanations as practice topics rather than memorizing longer scripts.
- Finish by naming what evidence would change your decision.
Primary sources
Use these primary references to verify the technical models behind this guide.
Editorial reviewProduct claims were checked against the current experience. Technical references use primary documentation where the guide depends on platform or framework behavior. Found an issue? Send a correction.
Turn the guide into a retry
Choose one section, practice it under interview conditions, review the evidence, and repeat the same skill with a new prompt. Improvement becomes reliable when it survives a different context.
Start a mock interview