roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Explain how Node.js really works when an interviewer digs in: the event loop, asynchronous patterns, streams and the module system, and how they shape server-side design.
298 of 298 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 298 new. 0 cut, outside your plan.
Node.js questions are folded into JavaScript backend and full-stack loops: the runtime comes up while the interviewer is already talking about the language or an API you built, and a take-home is read for how it handles errors and load. A common opener is a snippet whose output you must predict: a process.nextTick callback, a then on a resolved promise, a zero-delay setTimeout and a setImmediate. A good answer names the queues, including why the timer and the immediate can swap places when scheduled from the main module but not from inside an I/O callback.
The follow-ups get practical. Why does one large synchronous JSON.parse stall every other request? Why does a copy built on data events exhaust memory when the destination is slow, and what do write() returning false and the 'drain' event fix? Why did a rejected promise in an async Express 4 handler never reach the error middleware? In what order do a NestJS guard, interceptor and pipe see a request?
Naming the mechanism is a passing answer early in a career. From senior level up, the snippet becomes a symptom, such as latency climbing while one core sits at full load or a process that exits on an unhandled rejection, and the interviewer listens for the first measurement you would take and what the fix costs: a worker thread, a second process, a stream.
The frameworks in the middle of this plan are layers over the runtime's http module and inherit its single thread, so the runtime comes first. The event loop leads because most later answers depend on what runs when; module resolution follows, CommonJS and ES modules side by side. Streams and buffers precede files and sockets because those APIs hand you streams. The module ends where its mechanics become production symptoms: worker threads and clustering for when one thread is not enough, and errors and observability for when something fails.
The second module moves from the process to the application. Express comes first because it adds little over the runtime: its middleware chain is functions called in sequence, and its error handler is one more, told apart by its four parameters. NestJS follows because it runs on Express by default and builds structure on top: modules and dependency injection wire the code, guards and interceptors give the pipeline named stages, and microservice transports carry the controller model onto message brokers.
npm closes the plan with a different concern: not how a process runs but how code reaches it, from version ranges and the lockfile through workspaces to publishing a package of your own.
A frontend developer already knows the language; the runtime is the gap. The browser has an event loop too, but no `process.nextTick`, no named phases and no backpressure, so read the runtime module whole before either framework; by topics, not the by frequency the page opens on, is the study order that keeps the `nextTick` questions ahead of the Express ones. A Java or .NET developer has the opposite profile: NestJS providers will feel familiar from Spring or ASP.NET Core, and the hours belong in the runtime, where a pool of request threads gives way to one thread running everyone's callbacks. A week out, set aside whichever framework the posting does not name, then narrow importance to must know; it thins the runtime module without dropping it, and framework questions on this stack tend to end up there anyway. The plan covers the runtime and its frameworks, not the language underneath or the data behind a service. Closures, prototypes and how `this` gets bound are in the [JavaScript roadmap](/roadmaps/javascript), a first stop if the language is shaky; a Node service's queries, transactions and caches belong to the [Backend Developer roadmap](/roadmaps/backend).
A frontend developer already knows the language; the runtime is the gap. The browser has an event loop too, but no process.nextTick, no named phases and no backpressure, so read the runtime module whole before either framework; by topics, not the by frequency the page opens on, is the study order that keeps the nextTick questions ahead of the Express ones. A Java or .NET developer has the opposite profile: NestJS providers will feel familiar from Spring or ASP.NET Core, and the hours belong in the runtime, where a pool of request threads gives way to one thread running everyone's callbacks.
A week out, set aside whichever framework the posting does not name, then narrow importance to must know; it thins the runtime module without dropping it, and framework questions on this stack tend to end up there anyway.
The plan covers the runtime and its frameworks, not the language underneath or the data behind a service. Closures, prototypes and how this gets bound are in the JavaScript roadmap, a first stop if the language is shaky; a Node service's queries, transactions and caches belong to the Backend Developer roadmap.