Common Node.js Interview Questions

Node.js interviews typically probe your understanding of the event loop, asynchronous programming, the module system, and how Node handles I/O and concurrency without traditional multithreading. This guide walks through the questions that come up most often, with concise, accurate answers you can use to prepare or to sanity-check your own understanding before an interview.

The event loop is the mechanism that lets single-threaded Node.js perform non-blocking I/O by offloading operations to the system kernel or a thread pool and processing their callbacks later. Its main phases, in order, are: timers (setTimeout/setInterval callbacks), pending callbacks (deferred I/O callbacks), poll (retrieving new I/O events and executing their callbacks), check (setImmediate callbacks), and close callbacks (e.g., socket.on('close')). Between phases, Node drains the microtask queue (process.nextTick, then Promise callbacks).

Blocking code executes synchronously and halts the entire event loop until it finishes, such as fs.readFileSync. Non-blocking code, like fs.readFile, starts an operation and immediately returns control to the event loop, with a callback (or promise) invoked once the operation completes. Because Node is single-threaded for JavaScript execution, blocking calls in hot paths can freeze the whole application for all concurrent requests.

Node's JavaScript execution runs on a single thread, but I/O operations (file system, network, DNS) are delegated to the operating system's asynchronous APIs or to libuv's thread pool (default size 4). The event loop polls for completed operations and dispatches their callbacks back onto the single JS thread, giving the appearance of concurrency for I/O-bound workloads while CPU-bound work still runs sequentially on that one thread.

CommonJS (require/module.exports) loads modules synchronously and resolves them at runtime, allowing conditional and dynamic requires. ES modules (import/export) are statically analyzed, loaded asynchronously, support top-level await, and are enabled via the .mjs extension or "type": "module" in package.json. ESM imports are live bindings to the exported values, whereas CommonJS exports are copies of the values at the time of require, unless you export an object and mutate its properties.

A process is an independent instance of a running program with its own memory space; a thread is a unit of execution within a process that shares that process's memory. Node.js runs your JavaScript on a single main thread within one process, but internally uses libuv's thread pool for certain blocking operations (like some fs, crypto, and DNS calls) and can spawn additional OS processes via child_process or additional threads via worker_threads for CPU-intensive work.

The cluster module lets a Node.js application spawn multiple worker processes that share the same server port, each running its own event loop and V8 instance, effectively utilizing multiple CPU cores. It's used to scale a single-threaded Node app horizontally on a multi-core machine; the master process forks workers and load-balances incoming connections across them, and if a worker crashes it can be respawned without taking down the whole app.

Streams are objects that let you read or write data piece by piece (in chunks) instead of loading it all into memory at once. Node has four types: Readable, Writable, Duplex, and Transform. They're useful for processing large files, proxying HTTP responses, or piping data between sources and destinations efficiently, since data flows and is processed incrementally, keeping memory usage low and improving time-to-first-byte.

A Buffer is a fixed-size chunk of raw binary data allocated outside the V8 JavaScript heap, used to handle binary data such as file contents, TCP streams, or images. Because JavaScript strings weren't originally designed for binary data, Node introduced the Buffer class to work directly with octets efficiently, and it's the underlying data type used by Streams when working with binary content.

The child_process module lets Node.js spawn and interact with OS-level subprocesses, useful for running shell commands or CPU-heavy tasks outside the main event loop. Key methods are exec (buffers output, runs via a shell, good for short commands), execFile (runs a file directly without a shell), spawn (streams output, ideal for long-running or large-output processes), and fork (spawns a new Node.js process with an IPC channel for message passing, commonly used with the cluster module).

process.nextTick() queues a callback to run immediately after the current operation completes, before the event loop continues to the next phase — it has higher priority than Promises and all event loop phases. setImmediate() queues a callback to run in the check phase of the event loop, after I/O callbacks in the current iteration. In practice, nextTick callbacks always run before setImmediate callbacks when both are scheduled from the main module.