Node.js interviews revolve around the event loop, asynchronous patterns, Express or NestJS, and the consequences of a single-threaded runtime. Below are the most common questions with model answers. Junior: core theory, definitions, and simple practical cases.
The event loop repeatedly processes queues of completed operations in phases: timers for setTimeout and setInterval, pending callbacks, poll for incoming I/O, check for setImmediate, and close callbacks. Between every phase Node drains the microtask queue — process.nextTick first, then promise callbacks. This is why a long synchronous function blocks every request on the server: nothing else can run until it returns.
process.nextTick queues a callback to run before the event loop continues to the next phase, ahead of promise microtasks. setImmediate schedules the callback for the check phase of the next iteration. nextTick therefore always runs sooner, and recursive nextTick calls can starve the event loop entirely, which is why setImmediate is the safer default for deferring work.
A Promise represents a value that will be available later and is either pending, fulfilled, or rejected. Promise.all resolves when every input resolves but rejects immediately on the first rejection, discarding the other results — right when you need all of them to proceed. Promise.allSettled always resolves with a status and value for each entry, which suits independent operations where one failure should not cancel the rest.
You wrap awaited calls in try/catch, or attach .catch to the returned promise. In Express, an error thrown inside an async handler is not caught by the framework unless you forward it to next(), so most teams use a wrapper or express-async-errors. An unhandled rejection terminates the process by default in modern Node, which is intentional — the process is in an unknown state and should be restarted.
Streams process data in chunks, so memory usage stays constant regardless of payload size and the first byte can be sent before the last is read. Reading a two-gigabyte file into a Buffer exhausts memory and delays the response; piping it streams straight to the client. Streams also compose through pipe or pipeline, letting you chain decompression, transformation, and output with backpressure handled for you.
Middleware is a function receiving request, response, and next, executed in registration order to form a pipeline. Calling next() hands control to the next middleware; not calling it and not sending a response leaves the request hanging. Passing an argument to next() skips ahead to error-handling middleware, which is recognised by having four parameters.
Because JavaScript runs on one thread, a CPU-heavy computation blocks every pending request. Worker threads run JavaScript in parallel threads within the same process, communicating by message passing and shared array buffers, which suits hashing, image processing, or parsing. The alternatives are offloading to a separate service or a job queue — clustering only adds processes and does not make a single request faster.
In a real interview you speak under pressure. Cam asks these same questions, scores every answer, and shows exactly what to fix.
Practice a Junior Node.js Backend interview →