Prices shown are a USD base. Your local-market price is calculated at checkout in your own currency, plus any local sales tax.
What is inside
20 chapters, in the order the interviews tend to ask them:
The event loop, phases and scheduling
CPU-bound work, worker threads and clustering
Async control flow, promises and cancellation
Modules, package resolution and the ESM split
Streams and backpressure
Buffers, binary data and typed arrays
Filesystem access, paths and file watching
HTTP servers, keep-alive and connection handling
Express, middleware and routing
REST API design, versioning and contracts
Input validation, parsing and shared contracts
Error handling, failure modes and resilience
Testing a Node.js service
Databases, queries and connection pooling
Authentication, authorisation and secrets handling
Caching, queues and background work
Logging, metrics and tracing
Performance, memory and leak diagnosis
Configuration, secrets and process lifecycle
Deployment, scaling and staying available
How the answers are built
Each chapter opens with the checklist the question is really testing. A few from this pack:
A single loop iteration runs the timers, pending callbacks, idle and prepare, poll, check and close phases in that fixed order.
JavaScript on the main thread cannot be preempted, so a long synchronous block stops every socket that process owns.
An await inside a loop serialises independent operations, so work should be started first and awaited afterwards.
Resolution is an algorithm with named steps, and the ESM form walks node_modules upwards from the importing file before consulting the package's exports map.
Readable, writable, duplex and transform streams are layered on top of the same flow control contract.
Buffer.allocUnsafe hands back a slice of a shared pool, so small buffers share memory with unrelated allocations.
Questions this pack covers
Walk me through each phase of the Node event loop
Why do promise callbacks run before timer callbacks inside a callback
When should CPU work move to a worker thread?
How does a worker thread share data with the main thread?
Why do sequential awaits inside a loop waste throughput?
How does Promise.all differ from Promise.allSettled in practice?
What algorithm resolves a bare specifier to a file on disk?
How does the exports field replace the main field?
Each one is answered in full in the pack, with the reasoning written out rather than a bullet list.
