Which Node version to target?

Node 20 LTS or 22. Know ESM interop, --watch, fetch built-in, and node:test.

Express is still most common in interviews; Fastify and NestJS are growing. Know what each solves.

How is Node different from browser JS?

Same language, different runtime: Node has filesystem, network, and child_process APIs, plus its own module system. The event loop has additional phases.

What about TypeScript on Node?

Very common today. Know tsx/ts-node/Node native type stripping (--experimental-strip-types).

How do you scale Node?

Stateless services behind a load balancer, cluster/PM2 to use all cores, or move CPU-heavy work to workers or a different language.

Node.js Interview Questions (2026) — 100 Q&A

Node.js is a server-side JavaScript runtime built on Chrome's V8 engine and the libuv async I/O library. Unlike browser JS, Node.js has no DOM, `window`, or browser APIs; instead it exposes OS-level modules like `fs`, `net`, `child_process`, and `http`. Node.js uses CommonJS modules by default (though ESM is now fully supported), runs as a single process on the server, and is designed for I/O-heavy workloads like web servers and CLI tools. Node.js also exposes globals such as `process`, `Buffer`, and `__dirname` that do not exist in browsers.

The event loop is the mechanism that allows Node.js to perform non-blocking I/O despite running on a single thread. It continuously cycles through phases: timers, pending callbacks, idle/prepare, poll, check, and close callbacks. During the poll phase it blocks waiting for I/O events if no timers are due, then drains ready callbacks. Between each phase, Node drains the `process.nextTick` queue and the microtask (Promise) queue. This means async callbacks never interrupt synchronous code — they queue up and execute only when the call stack is empty.

Non-blocking I/O means that operations like reading a file or making a network request are initiated and then control returns immediately to the caller — the result is delivered later via a callback, Promise, or event. Under the hood, libuv either delegates to the OS's async API (e.g., epoll on Linux) or offloads the work to a thread pool, then posts a completion event back to the event loop. This lets a single Node.js process handle thousands of concurrent connections without creating a thread per connection.

`require()` is CommonJS (CJS): synchronous, dynamic (can be called anywhere in code), and resolved at runtime. `import` is ES Module (ESM): statically analysed, asynchronous, and hoisted. In Node.js, CJS files use `.js` (with no `"type"` field or `"type":"commonjs"`) and ESM files use `.mjs` or `.js` with `"type":"module"` in `package.json`. CJS exports are objects (`module.exports`), while ESM uses named and default exports. Dynamic `import()` works in both systems and always returns a Promise.

js
// CJS
const fs = require('fs');
// ESM
import { readFile } from 'node:fs/promises';

`exports` is simply a reference that initially points to the same object as `module.exports`. You can safely add properties to `exports` (e.g., `exports.foo = 1`) and they appear on `module.exports`. However, if you reassign `exports` entirely (`exports = function() {}`), you break the reference — the module still exports the original `module.exports` object. To export a function or class as the whole module value you must use `module.exports = myFunction`.

`__dirname` is the absolute path of the directory containing the current module file; `__filename` is the absolute path of the current file itself. Both are injected by the CommonJS module wrapper function. In ES Modules these globals do not exist — you recreate them using `import.meta.url` and the `path`/`url` modules:

js
import { fileURLToPath } from 'node:url';
import path from 'node:path';
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

By convention, Node.js async callbacks receive the error as their first argument and the result as the second. If the operation succeeded, the first argument is `null` or `undefined`; if it failed, it's an `Error` object. You must always check the first argument before using the result.

js
fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) return console.error(err);
  console.log(data);
});

This convention is consistent across the entire Node.js core API and most older npm packages. `util.promisify()` converts any error-first callback function into one that returns a Promise.

A Promise is an object representing the eventual completion or failure of an asynchronous operation. It has three states: pending, fulfilled, or rejected. You chain `.then()` for success and `.catch()` for errors, avoiding nested callback pyramids. Node.js core began exposing Promise-based APIs via `fs/promises`, `dns/promises`, etc. `util.promisify()` wraps legacy callback APIs. `Promise.all()` runs tasks in parallel; `Promise.allSettled()` waits for all even if some reject.

js
import { readFile } from 'node:fs/promises';
const data = await readFile('file.txt', 'utf8');

`EventEmitter` is the base class (from `node:events`) for objects that emit named events and allow listeners to subscribe. Many core Node.js classes extend it — `Stream`, `http.Server`, `child_process.ChildProcess`, etc. You emit events with `.emit(name, ...args)` and listen with `.on(name, handler)` or `.once()` for one-time listeners. `.removeListener()` / `.off()` clean up handlers to prevent memory leaks.

js
import { EventEmitter } from 'node:events';
const bus = new EventEmitter();
bus.on('data', chunk => console.log(chunk));
bus.emit('data', 'hello');

Use `http.createServer()` with a callback that receives `IncomingMessage` (req) and `ServerResponse` (res). Call `res.writeHead()` to set status and headers, then `res.end()` to send the body.

js
import http from 'node:http';
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello World');
});
server.listen(3000, () => console.log('Listening on :3000'));

In production you'd use Express or Fastify on top of this, but understanding the raw `http` module is fundamental to understanding how frameworks work.

The modern approach uses `fs/promises` with `async/await`. For small files you can read the whole thing into memory; for large files use a readable stream.

js
import { readFile } from 'node:fs/promises';
try {
  const data = await readFile('config.json', 'utf8');
  const config = JSON.parse(data);
} catch (err) {
  console.error('Read failed:', err.message);
}

The older callback-based `fs.readFile` still works and is useful when you need maximum compatibility. Specify the encoding (`'utf8'`) to get a string; omit it to get a raw `Buffer`.

A `Buffer` is a fixed-size chunk of memory outside the V8 heap, used to work with binary data — network packets, file contents, crypto outputs — before it's decoded to a string. Create Buffers with `Buffer.from(data, encoding)`, `Buffer.alloc(size)` (zero-filled, safe), or `Buffer.allocUnsafe(size)` (faster, uninitialized). Convert to string with `buf.toString('utf8')` or `buf.toString('base64')`.

js
const buf = Buffer.from('hello', 'utf8');
console.log(buf.toString('hex')); // 68656c6c6f

libuv maintains a thread pool (default size 4, max 1024) for operations the OS does not support asynchronously: file system operations (`fs.*`), DNS lookups via `getaddrinfo`, crypto operations (`crypto.pbkdf2`, `crypto.randomBytes`), and user-space work via `worker_threads` and `child_process`. Network I/O is NOT in the thread pool — it uses the OS async APIs (epoll/kqueue/IOCP). Set `UV_THREADPOOL_SIZE` before startup to increase the pool:

bash
UV_THREADPOOL_SIZE=16 node server.js

A saturated thread pool causes fs/dns operations to queue behind each other, adding latency invisible to the event loop. Monitor it with `clinic doctor`.

The cluster module lets you fork `os.cpus().length` worker processes that all listen on the same port. The primary process accepts connections and distributes them to workers using round-robin scheduling (default on all platforms except Windows). Each worker is a separate Node.js process with its own event loop and V8 heap — no shared memory. Workers communicate with the primary via IPC. If a worker crashes, the primary can respawn it. In production, PM2 cluster mode wraps this with zero-downtime reloads: workers are replaced one at a time so the server never fully restarts.

js
import cluster from 'node:cluster';
import os from 'node:os';
if (cluster.isPrimary) {
  os.cpus().forEach(() => cluster.fork());
} else { startServer(); }

`stream.pipeline()` (from `node:stream/promises`) chains streams and handles: (1) **automatic cleanup** — if any stream in the chain emits an error or the pipeline is aborted, all streams are destroyed, preventing resource leaks; (2) **error propagation** — the returned Promise rejects with the first error from any stream; (3) **backpressure** is respected throughout. Manual `.pipe()` does not propagate errors — an error on one stream leaves the others open and leaking file handles or connections.

js
import { pipeline } from 'node:stream/promises';
import { createReadStream, createWriteStream } from 'node:fs';
import { createGzip } from 'node:zlib';
await pipeline(createReadStream('in.log'), createGzip(), createWriteStream('in.log.gz'));

Express middleware is a function with signature `(req, res, next)`. The app maintains an ordered stack of middleware registered with `app.use()`, `app.get()`, etc. When a request arrives, Express walks the stack calling each middleware. Calling `next()` advances to the next middleware; calling `next(err)` skips to the first error-handling middleware. Error middleware has the special 4-argument signature `(err, req, res, next)` — Express only routes to it when `next` is called with an argument.

js
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: err.message });
});

Always define error middleware last, after all routes.

`AsyncLocalStorage` (from `node:async_hooks`) provides request-scoped storage that automatically propagates through the entire async call chain — Promises, `await`, timers, callbacks — without passing context objects as arguments. It replaced the fragile `cls-hooked` library which patched Node.js internals. A common use case is storing the current user or trace ID for the lifetime of an HTTP request.

js
import { AsyncLocalStorage } from 'node:async_hooks';
const requestCtx = new AsyncLocalStorage();
app.use((req, res, next) => requestCtx.run({ userId: req.user.id }, next));
function getUser() { return requestCtx.getStore()?.userId; }

Graceful shutdown ensures in-flight requests complete before the process exits. Listen for `SIGTERM` (sent by container orchestrators like Kubernetes). Stop accepting new connections with `server.close(callback)` — this closes the listening socket but keeps existing connections alive until they finish. For keep-alive connections you may need `server.closeAllConnections()` (Node 18.2+) or a timeout. Then close DB pools, flush logs, and call `process.exit(0)`.

js
process.on('SIGTERM', () => {
  server.close(() => {
    db.end().then(() => process.exit(0));
  });
  setTimeout(() => process.exit(1), 10_000).unref();
});

**Jest**: the most popular choice; rich assertion library, snapshot testing, mocking, code coverage. Works out of the box with CJS; for ESM requires `--experimental-vm-modules` or `babel-jest`. **Vitest**: built on Vite, natively supports ESM and TypeScript without transpilation, compatible Jest API, faster for frontend-adjacent Node.js code. **`node:test`** (Node.js 18+): built-in test runner, no install needed. Supports `test()`, `describe()`, `before`/`after` hooks, subtests, mock functions, and TAP output. Good for utilities and libraries where you want zero dev dependencies.

js
import { test } from 'node:test';
import assert from 'node:assert';
test('adds', () => assert.equal(1 + 1, 2));

Install `@opentelemetry/sdk-node`, `@opentelemetry/auto-instrumentations-node`, and an exporter (e.g., `@opentelemetry/exporter-otlp-http`). Create a `tracing.js` that initialises the SDK before any other imports and start it with `-r ./tracing.js`. Auto-instrumentations patch `http`, `express`, `pg`, `redis`, `fs`, etc. automatically.

js
import { NodeSDK } from '@opentelemetry/sdk-node';
import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
const sdk = new NodeSDK({ instrumentations: [getNodeAutoInstrumentations()] });
sdk.start();

Spans are exported to your backend (Jaeger, Honeycomb, Datadog). Manually create spans with the `@opentelemetry/api` tracer for custom operations.

ESM loaders let you intercept module resolution and loading. With `--import ./register.js` (Node.js 20.6+) you register hooks via `module.register()` from within the process without a subprocess. A loader module exports `resolve` and `load` hooks. `resolve` receives the specifier and can rewrite it; `load` receives the resolved URL and can transform the source (e.g., strip TypeScript types). Example for path aliases:

js
// register.js
import { register } from 'node:module';
register('./aliases-loader.js', import.meta.url);
// aliases-loader.js
export function resolve(specifier, ctx, nextResolve) {
  if (specifier.startsWith('@/'))
    specifier = specifier.replace('@/', new URL('../src/', import.meta.url).href);
  return nextResolve(specifier, ctx);
}

Loaders run in a separate thread from the main module to avoid deadlocks. This replaces the older `--experimental-loader` flag which ran loaders in-process.

Extend `Readable` in object mode, open the file with `fs.open`, and use `fs.read` to pull chunks into a buffer, splitting on newlines. Or, more idiomatically, compose built-in streams:

js
import { createReadStream } from 'node:fs';
import { createInterface } from 'node:readline';
import { Readable } from 'node:stream';
export function lineStream(filePath) {
  const rl = createInterface({
    input: createReadStream(filePath),
    crlfDelay: Infinity,
  });
  return Readable.from(rl); // async iterable → Readable
}
for await (const line of lineStream('huge.log')) {
  process(line); // only one chunk in memory at a time
}

`Readable.from()` wraps any async iterable into a proper Readable, respecting backpressure automatically. Memory usage is bounded by the internal highWaterMark (16 lines by default in object mode) rather than the file size.

`SharedArrayBuffer` (SAB) is a fixed-length raw binary memory region that is shared — not copied — between threads. You create it in the main thread, pass it to a worker via `workerData` or `postMessage` with the transfer list, and both sides create a TypedArray view over it (e.g., `new Int32Array(sab)`). Concurrent reads/writes without coordination produce data races. `Atomics` provides lock-free atomic operations: `Atomics.add`, `Atomics.compareExchange`, `Atomics.store`, and `Atomics.load`. `Atomics.wait(ia, index, value)` blocks the calling thread until the value changes; `Atomics.notify(ia, index, count)` wakes blocked threads.

js
const sab = new SharedArrayBuffer(4);
const ia = new Int32Array(sab);
// Worker: Atomics.add(ia, 0, 1) — thread-safe increment

A minimal pool tracks idle connections, pending acquire callbacks, and total size. `acquire()` returns an idle connection or queues a callback if at capacity. `release(conn)` checks if anyone is waiting, otherwise returns to the idle list. Eviction runs on a timer checking `lastUsed` timestamps.

js
class Pool {
  constructor({ create, destroy, max = 10, idleTimeout = 30000 }) {
    this.create = create; this.destroy = destroy;
    this.max = max; this.idle = []; this.pending = []; this.size = 0;
  }
  async acquire() {
    if (this.idle.length) return this.idle.pop();
    if (this.size < this.max) { this.size++; return this.create(); }
    return new Promise(resolve => this.pending.push(resolve));
  }
  release(conn) {
    if (this.pending.length) return this.pending.shift()(conn);
    conn.lastUsed = Date.now(); this.idle.push(conn);
  }
}

Production pools also handle connection validation (ping on acquire), error on broken connections, circuit breaking, and metrics on pool utilisation.

`AsyncResource` lets you manually associate a piece of code with an async context that already exists. When libuv thread pool callbacks execute (e.g., a `fs.readFile` completion or a custom `Napi::AsyncWorker` done callback), they run outside any async context — `AsyncLocalStorage.getStore()` returns `undefined`. By wrapping the callback with `asyncResource.runInAsyncScope(callback)`, you re-enter the original context.

js
import { AsyncResource } from 'node:async_hooks';
class TracedPool {
  run(fn) {
    const res = new AsyncResource('TracedPool');
    threadPool.submit(() => res.runInAsyncScope(fn));
  }
}

Node.js's `events.EventEmitterAsyncResource` extends `EventEmitter` with this behaviour built in.

The key is to treat the upload as a stream and pipe it directly to its destination without accumulating it in memory. `busboy` is the canonical multipart parser: it parses the `multipart/form-data` stream and emits a readable stream per file part, which you can pipe directly to S3 (via AWS SDK's `upload` stream API), a write stream, or a Transform.

js
import Busboy from 'busboy';
app.post('/upload', (req, res) => {
  const bb = Busboy({ headers: req.headers });
  bb.on('file', (name, stream, info) => {
    stream.pipe(s3UploadStream(info.filename));
  });
  req.pipe(bb);
  bb.on('finish', () => res.sendStatus(200));
});

Memory usage stays bounded to a few chunks regardless of file size. `multer` wraps busboy for Express. Always set `limits.fileSize` to reject oversized uploads early.

Model the producer as a `Readable` and the consumer as a `Writable`. The `Readable`'s `_read` is called when the consumer is ready for more — this is the pull signal. Backpressure is automatic: when the Writable's buffer is full, `write()` returns `false`, pausing the pipe.

js
import { Readable, Writable } from 'node:stream';
const producer = new Readable({
  objectMode: true,
  read() { this.push(generateWork()); /* push null when done */ },
});
const consumer = new Writable({
  objectMode: true,
  async write(item, _, done) {
    await processItem(item);
    done(); // signal ready for next
  },
  highWaterMark: 4, // queue at most 4 items
});
await pipeline(producer, consumer);

The `highWaterMark` on the Writable controls queue depth. When 4 items are buffered, the Readable pauses automatically.

The `nextTick` queue is drained **completely** before the event loop advances to the next phase. If a `nextTick` callback schedules another `nextTick`, the loop never exits to poll for I/O. Example:

js
function recursiveTick() {
  process.nextTick(recursiveTick);
}
recursiveTick(); // starves all I/O, timers, and setImmediate forever
fs.readFile('file.txt', cb); // cb NEVER fires

Compare with `setImmediate(recursiveImmediate)`: the check phase runs once per loop iteration, so I/O can still be processed between `setImmediate` calls. The fix is to use `setImmediate` for recursive async work, or process a batch of items per tick. `process.nextTick` is appropriate for short, non-recursive deferred callbacks only.

Use N-API when you need (1) raw CPU performance impossible to achieve in JS, (2) bindings to a C/C++ library (e.g., `libvips` for sharp), (3) access to hardware or OS APIs, or (4) deterministic memory layouts. With `node-addon-api` (C++ wrapper): define an `Napi::Object Init` export, use `Napi::Function::New` to expose functions, and `Napi::AsyncWorker` for thread-pool work to avoid blocking the event loop.

cpp
Napi::Value Add(const Napi::CallbackInfo& info) {
  double a = info[0].As<Napi::Number>().DoubleValue();
  double b = info[1].As<Napi::Number>().DoubleValue();
  return Napi::Number::New(info.Env(), a + b);
}

Build with `node-gyp`. N-API's stable ABI means the `.node` file works across Node.js versions without recompilation, unlike the old `nan`-based approach.

Use a `Map` keyed by event name to a `Set` of strongly-typed listeners, leveraging TypeScript generics to enforce handler signatures at compile time.

ts
type EventMap = Record<string, unknown>;
class EventBus<T extends EventMap> {
  private listeners = new Map<keyof T, Set<(payload: T[keyof T]) => void>>();
  on<K extends keyof T>(event: K, handler: (payload: T[K]) => void): () => void {
    if (!this.listeners.has(event)) this.listeners.set(event, new Set());
    (this.listeners.get(event) as Set<(p: T[K]) => void>).add(handler);
    return () => this.off(event, handler);
  }
  off<K extends keyof T>(event: K, handler: (payload: T[K]) => void) {
    this.listeners.get(event)?.delete(handler as never);
  }
  emit<K extends keyof T>(event: K, payload: T[K]) {
    this.listeners.get(event)?.forEach(h => (h as (p: T[K]) => void)(payload));
  }
}

Usage: `const bus = new EventBus<{ userCreated: { id: string } }>()`. The `on` return value is an unsubscribe function, preventing listener leaks.

Pipe the file through a line-splitting Transform, parse each line as JSON:

js
import { createReadStream } from 'node:fs';
import { Transform } from 'node:stream';
import { pipeline } from 'node:stream/promises';
function ndjsonParser() {
  let buf = '';
  return new Transform({
    objectMode: true,
    transform(chunk, _, done) {
      buf += chunk.toString();
      const lines = buf.split('\n');
      buf = lines.pop(); // save incomplete trailing line
      for (const line of lines) {
        if (line.trim()) this.push(JSON.parse(line));
      }
      done();
    },
    flush(done) {
      if (buf.trim()) this.push(JSON.parse(buf));
      done();
    },
  });
}
await pipeline(
  createReadStream('logs.ndjson'),
  ndjsonParser(),
  new Writable({ objectMode: true, write(obj, _, cb) { process(obj); cb(); } })
);

Memory is bounded to one chunk at a time plus the incomplete line buffer. `flush` handles the last line if the file doesn't end with a newline.

Redis Streams (`XADD`/`XREADGROUP`/`XACK`) provide durable, at-least-once delivery with consumer groups — superior to `LPUSH/BRPOP` (no acknowledgement) and Pub/Sub (fire-and-forget).

js
// Producer
await redis.xadd('jobs', '*', 'type', 'email', 'payload', JSON.stringify(data));
// Consumer
while (true) {
  const [[, entries]] = await redis.xreadgroup(
    'GROUP', 'workers', 'worker-1',
    'COUNT', 10, 'BLOCK', 2000, 'STREAMS', 'jobs', '>'
  );
  for (const [id, fields] of entries) {
    await processJob(Object.fromEntries(fields));
    await redis.xack('jobs', 'workers', id);
  }
}

Unacknowledged messages stay in the PEL (Pending Entries List). A reaper process uses `XAUTOCLAIM` to reclaim jobs idle > N seconds and re-enqueue them. BullMQ abstracts this entire pattern over Redis Streams.

The pattern (also called a "dataloader" or "in-flight deduplication") stores in-progress Promises keyed by query fingerprint. If a second identical request arrives before the first resolves, it receives the same Promise instead of triggering a new DB query.

ts
class CoalescingCache<K, V> {
  private inflight = new Map<K, Promise<V>>();
  private cache = new Map<K, V>();
  async get(key: K, fetcher: () => Promise<V>, ttlMs = 5000): Promise<V> {
    if (this.cache.has(key)) return this.cache.get(key)!;
    if (this.inflight.has(key)) return this.inflight.get(key)!;
    const p = fetcher().then(val => {
      this.cache.set(key, val);
      this.inflight.delete(key);
      setTimeout(() => this.cache.delete(key), ttlMs);
      return val;
    }).catch(err => { this.inflight.delete(key); throw err; });
    this.inflight.set(key, p);
    return p;
  }
}

This reduces DB load dramatically under concurrent traffic for the same resource — a cold-start thundering herd that would fire 200 identical queries fires only one. `DataLoader` from Facebook generalises this with batching.

Node.js Interview Questions (2026)

Frequently Asked Questions

Which Node version to target?

Which framework?

How is Node different from browser JS?

What about TypeScript on Node?

How do you scale Node?

Related Topics

Ready to apply?