50 Node.js Interview Questions for 5+ Years Experience

How to use this list

Senior Node.js interviews rarely reward memorized one-liners. Interviewers want to hear how you reason about the event loop, memory, I/O, and production incidents. Use this list as a practice syllabus: answer out loud, then compare with the guidance below.

Group questions by topic and spend a day on each cluster. For every question, give a short definition, one concrete example from a service you have built, and one trade-off. If you only recite documentation wording, follow-up questions will expose gaps quickly.

• Day 1–2: event loop, timers, nextTick, promises, setImmediate
• Day 3: streams, buffers, backpressure, file and HTTP pipelines
• Day 4: error handling, unhandledRejection, process signals
• Day 5: clustering, worker threads, memory leaks, observability
• Day 6: mock interview covering mixed topics under time pressure

Event loop and async (sample questions)

Expect questions such as: What does the event loop do? Why can a CPU-heavy JSON parse freeze a Node server? What is the difference between process.nextTick and Promise.then? When does setImmediate run relative to setTimeout(fn, 0)? How would you detect event-loop lag in production?

A strong answer explains that JavaScript on the main thread runs one callback at a time, while libuv and the OS handle much of the I/O. Microtasks (nextTick, then promises) drain between callbacks. Recursive nextTick can starve I/O; worker threads or a separate process are better for CPU-bound work.

Streams and buffers

Common prompts: Readable vs Writable vs Transform; what is backpressure; why prefer stream.pipeline over manual pipe; when would you buffer instead of stream; how do you handle errors mid-pipeline?

Explain that streams process data in chunks so memory stays bounded. Backpressure pauses upstream when downstream is slow. Always attach error handlers or use pipeline so sockets and file descriptors close cleanly. Buffering the entire file is fine for small configs; it is a production risk for uploads and large exports.

Errors and reliability

Interviewers often ask how you structure Express error middleware, how you avoid unhandled promise rejections, and what you do when a dependency times out. Talk about operational vs programmer errors, centralized logging with request IDs, retries with jitter for idempotent calls, and failing fast on non-idempotent writes.

• Never swallow errors silently in async handlers — forward with next(err) or await safely
• Distinguish 4xx client mistakes from 5xx server failures in API design
• Circuit-break or shed load when downstream latency spikes
• Validate input early so bad data never reaches the database layer

Scaling and production

Topics include the cluster module vs process managers, sticky sessions, connection pool sizing, caching hot reads, horizontal scale of stateless APIs, and memory leak investigation with heap snapshots. Mention metrics you watch first: event-loop delay, heap used, active handles, p95 latency, error rate, and pool wait time.

For 5+ years experience, connect answers to incidents: a pool exhaustion caused by missing release on error paths, a leak from unbounded caches, or latency from synchronous crypto on the request path. That storytelling is more persuasive than listing APIs.

Sample answer shape

Question: How would you investigate a Node API that suddenly times out under load?

Answer outline: Confirm whether timeouts are at the load balancer, app, or database. Check event-loop lag and CPU — synchronous work would show high lag with modest I/O wait. Inspect connection pool wait metrics and slow-query logs. Look for recent deploys that added blocking work or removed an index. Mitigate with load shedding, fix the hot path, then add regression tests and alerts on pool wait and loop delay.

How to practice with HireReadyAI

After you can explain each topic in two minutes, run a Node.js mock interview and force yourself to answer without notes. Review the report for missing trade-offs and weak examples. Revisit only the weak topics, then repeat a shorter mock focusing on production debugging.