Node.js interviews come down to one big idea: how a single-threaded, non-blocking, event-driven runtime handles concurrency. If you understand the event loop and async patterns deeply, most Node questions follow. Used everywhere in backend and full-stack roles. Here are the Node.js interview questions that actually get asked, with answers. (See also our JavaScript guide.)
The runtime & event loop
- How does Node's event loop work, and its phases?
- Is Node single-threaded? How does it handle concurrency?
- What is the libuv thread pool, and what runs on it?
- process.nextTick vs setImmediate vs setTimeout.
- Blocking vs non-blocking code — and why a CPU-heavy task is dangerous.
Async patterns
- Callbacks vs promises vs async/await.
- What is callback hell and how do you avoid it?
- Error handling in async code; the error-first callback convention.
Core modules & patterns
- What are streams, and the four types?
- Buffers; the EventEmitter pattern.
- Middleware in Express — how does it work?
- Clustering and the worker_threads module — scaling Node.
How to prepare
Node rounds probe the runtime and async behavior verbally. Practise explaining the event loop out loud. Greenroom runs spoken technical interviews that follow up on your reasoning. Pair it with our JavaScript and backend guides.
Frequently asked questions
What are the most common Node.js interview questions?
Common Node.js questions cover the event loop and its phases, whether Node is single-threaded and how it handles concurrency, the libuv thread pool, process.nextTick vs setImmediate vs setTimeout, blocking vs non-blocking code, async patterns (callbacks, promises, async/await, error handling), streams and buffers, the EventEmitter pattern, Express middleware, and scaling with clustering and worker_threads.
Is Node.js single-threaded?
Node.js runs your JavaScript on a single main thread with an event loop, but it isn't entirely single-threaded: libuv provides a thread pool that handles certain operations like file I/O and crypto in the background. This lets Node handle many concurrent connections efficiently, as long as you avoid blocking the main thread with CPU-heavy synchronous work.
How does the Node.js event loop work?
The event loop continuously processes phases — timers (setTimeout/setInterval), pending callbacks, poll (I/O), check (setImmediate) and close callbacks — running queued callbacks when the call stack is empty. Microtasks like resolved promises and process.nextTick run between phases. This is how single-threaded Node achieves non-blocking concurrency for I/O-bound workloads.
How should I prepare for a Node.js interview?
Focus on deeply understanding the event loop, the single-threaded non-blocking model, the libuv thread pool, and async patterns, since most Node questions build on these. Practise explaining why CPU-heavy tasks block the server and how to offload them, out loud with a voice-based mock interview that follows up, because Node rounds are conceptual and verbal.