Node.js quiz — 75 questions with answers and explanations

20 Beginner · 55 Intermediate

All 75 Node.js quiz questions below come with a short explanation, visible right on the page — no sign-in needed. They're grouped by beginner and intermediate levels and 23 subtopics, so you can revise one part at a time. Choose Try Node.js quiz above to take a scored run and review the questions you got wrong.

What the Node.js quiz covers

Express7
Core APIs6
NestJS6
Event Loop5
Operations5
Streams & Buffer5
HTTP4
Modern Node4
Modules4
Package Management4
Process & Env4
Security4
Performance3
Database2
Promises & Async2
Testing2
Timers2
Architecture1
Error Handling1
Events1
Tooling1
Operations1
Worker Threads1

Want long-form answers? Read 89 Node.js interview questions with answers — same topic, in more depth.

Beginner level — 20 Node.js questions

Question 1Timers

`clearTimeout` right after `setTimeout` — what does this code print?

javascript

const timer = setTimeout(() => console.log('tick'), 0)
clearTimeout(timer)
console.log('done')

A.done
B.done tick
C.(nothing is printed)
D.tick done

Answer: A

Prints only done. setTimeout returns a handle; clearTimeout(handle) runs synchronously right after, so the timer is cancelled before the event loop gets a chance to run it. The tick callback is never called. (FREE)

References

Question 2Promises & Async

What an `async` function returns — what does this code print?

javascript

async function getValue() {
  return 1
}
console.log(getValue())

A.undefined
B.Promise { 1 }
C.1
D.[object Promise]

Answer: B

Promise { 1 }. An async function always returns a Promise — return 1 is wrapped into a promise resolved with 1. Without await, console.log receives that promise itself, and Node's inspect shows it along with the resolved value. (FREE)

References

Question 3Streams & Buffer

`Buffer.length` vs `String.length` — what does this code print?

javascript

const buf = Buffer.from('hé')
console.log(buf.length, 'hé'.length)

A.3 2
B.2 2
C.2 3
D.3 3

Answer: A

3 2. Buffer.length counts BYTES after UTF-8 encoding — "é" takes 2 bytes, so the total is 3. String.length counts UTF-16 code units — "hé" is 2. Non-ASCII characters make these two numbers diverge. (FREE)

References

Question 4Event Loop

Node.js is described as "single-threaded" — what does that actually mean?

A.Single-threaded means Node can only handle one request at a time
B.Node.js is multithreaded: each request gets its own thread to run JavaScript on
C.The application's JavaScript runs on a single thread with an event loop
D.A Node process has exactly one OS thread, I/O included

Answer: C

Only JavaScript execution is single-threaded: one thread runs the application code, orchestrated by the event loop. Async I/O is delegated to the kernel (epoll/kqueue/IOCP) and libuv's thread pool, so a single Node process can still serve thousands of concurrent connections without a thread per request. (FREE)

References

Question 5Modules

What is the fundamental difference between `require()` (CommonJS) and `import` (ES Modules) in Node.js?

A.require loads a module synchronously at runtime and can be called anywhere
B.import is just another spelling of require with identical behaviour
C.require runs asynchronously and returns a Promise, so it needs await require(...)
D.Node.js cannot run ES Modules; import only works in browsers

Answer: A

require (CommonJS) is a synchronous function call that loads the module at runtime and can be called anywhere in the code. Static import (ESM) is resolved at parse time before execution, must be at the top level, and bindings are live; ESM also supports top-level await. Node runs ESM via .mjs files or "type": "module".

References

Question 6Error Handling

What is the "error-first callback" convention in Node.js?

A.The callback takes the error as its FIRST parameter ((err, data) => {})
B.Each API takes two separate callbacks: one for success and one for failure
C.The error is the callback's last parameter so it is easy to ignore when unneeded
D.Errors in an async callback are thrown and caught by a try/catch around the function call

Answer: A

Node's callback-style async APIs pass the error as the FIRST argument of the callback: fs.readFile(path, (err, data) => {...}). On success err is null; on failure err is an Error object and data is unreliable. This convention exists because a try/catch around the call can't catch errors thrown inside a callback that runs on a later tick.

References

Question 7Promises & Async

`Promise.allSettled` — what does this code print?

javascript

Promise.allSettled([
  Promise.resolve(1),
  Promise.reject(new Error('boom')),
]).then(results => {
  for (const r of results) console.log(r.status)
})

A.fulfilled rejected
B.rejected fulfilled
C.fulfilled
D.Uncaught Error: boom

Answer: A

Prints fulfilled then rejected. Unlike Promise.all (fail-fast), Promise.allSettled waits for every promise to settle and ALWAYS resolves with an array of { status, value | reason } in the original input order — rejections are wrapped into the result instead of failing the whole group. (FREE)

References

Question 8Process & Env

When implementing graceful shutdown for a Node.js server, which statement about the SIGTERM and SIGKILL signals is TRUE?

A.SIGTERM can be caught with process.on('SIGTERM', ...) to close the server, drain in-flight requests and exit; SIGKILL accepts no listener
B.The standard approach is calling process.exit(0) on the first line of the SIGTERM handler to exit as fast as possible
C.Node shuts down gracefully on SIGTERM by itself: it waits for in-flight requests before exiting, with no extra code needed
D.SIGKILL can also be caught with process.on('SIGKILL', ...) like any other signal, as long as you register early

Answer: A

SIGTERM (the signal orchestrators like Kubernetes/Docker send when they want to stop a container) can be caught with process.on('SIGTERM', handler) — the handler should server.close(), drain in-flight requests, close DB connections, then exit. SIGKILL and SIGSTOP cannot have listeners attached: the kernel terminates the process immediately, with no time to clean up. With no listener, the default is that SIGTERM also ends the process right away.

References

Question 9Process & Env

A Node app reads `process.env.DATABASE_URL` but gets `undefined`. Most common cause?

A.Node only reads fully uppercase environment variables
B.The variable's type must be declared in package.json before it can be read
C.process.env only works in CommonJS and not with ESM
D.The variable was never loaded into the process — Node does not read a .env file by itself

Answer: D

Node does NOT read .env files on its own. You must load it explicitly — using modern Node's --env-file=.env flag, or a library that loads it at the first import. And the loading must happen BEFORE any module reads the variable, otherwise it still sees undefined.

References

Node.js docs — process

Question 10Core APIs

Why use `path.join()` instead of concatenating paths with `/`?

A.It is mandatory when working with the fs module
B.It uses the operating system's correct separator and normalises the path
C.It is faster than string concatenation because it is optimised in C++
D.It creates the directory automatically when the path does not exist

Answer: B

path.join() uses the correct separator for the platform and normalizes the result — collapsing repeated separators, resolving ... Manual concatenation with / works on Linux but produces wrong paths on Windows, and easily creates // when a segment already has a leading or trailing separator.

References

Node.js docs — path

Question 11Core APIs

Why avoid `fs.readFileSync()` inside a request handler?

A.Because it cannot handle the error when the file does not exist
B.Because it cannot read large files
C.Because it blocks the main thread so every other request has to wait
D.Because it reads more slowly than the asynchronous version of the same operation

Answer: C

Because it blocks the main thread. Node handles all requests on the same thread, so while the file is being read no other request is processed — even unrelated ones. A 50-millisecond operation stalls the whole server for 50 milliseconds.

References

Node.js docs — API reference

Question 12Package Management

How do `dependencies` and `devDependencies` differ in package.json?

A.The second group can only be used in scripts and cannot be imported
B.The second group is not pinned to exact versions in the lockfile
C.The second group is only needed during development and is not installed for production
D.The second group is installed first so the main packages can use it

Answer: C

The latter group is only needed during development — compiler, test tools, linters — and is skipped when installing with the production-only flag. Separating them correctly makes deployment images much smaller and reduces the attack surface. Classification rule: any package imported by code that runs at execution time belongs to the first group.

References

npm docs — package.json

Question 13Core APIs

Is `__dirname` available in a Node ES Module file?

A.Yes, but its value is always the project root
B.No; it must be derived from import.meta.url or import.meta.dirname
C.No, and there is no way to obtain the directory path at all
D.Yes, but a compatibility flag must be enabled when running Node

Answer: B

No. Those variables are specific to the old module system. In the new module system, derive the path from import.meta.url and convert it, or use import.meta.dirname directly, available since Node 20.11.

References

Node.js docs — API reference

Question 14Streams & Buffer

What encoding does `buf.toString()` use with no argument?

A.An encoding inferred automatically from the buffer's contents
B.ASCII, so accented characters are lost
C.Base64, being the safest way to display bytes
D.UTF-8

Answer: D

UTF-8. This is the default for every conversion between strings and bytes in Node. Other encodings — hex, base64, latin1 — must be specified explicitly as an argument.

References

Node.js docs — Stream

Question 15Operations

What does the `NODE_ENV=production` variable affect?

A.Many libraries read it to disable checks and enable optimisations
B.Node stops writing to the console to reduce I/O cost
C.Node installs only the production dependencies at startup
D.Node enables optimisations and disables type checking when compiling

Answer: A

Node itself does not handle this variable. Its effect comes from libraries reading it themselves: Express reduces debugging output, React drops development warnings, and many libraries enable optimized code paths. It is a convention, not a runtime feature.

References

Node.js docs — Cluster

Question 16Express

In Express, what determines the order in which middleware run?

A.Express sorts them itself: the body parser always runs before the route handler
B.A more specific path takes precedence and runs first
C.The registration order through app.use / app.get and so on
D.The priority declared in each middleware's options

Answer: C

Registration order. Express runs middleware sequentially in the exact order they were registered via app.use/app.get. So body parser, CORS, and auth must be registered BEFORE the routes that need them — placed after, the route sees req.body as undefined or skips auth.

References

Express docs — Using middleware

Question 17Express

An Express middleware neither calls next() nor sends a response. What happens to the request?

A.It hangs until the client times out
B.Express returns 404 because no route finished handling the request
C.Express moves to the next middleware after a default wait
D.Express throws a warning that the middleware forgot to call next()

Answer: A

The request hangs — the client waits until timeout. Every middleware must end in one of two ways: send a response (res.json, res.send, res.end...) or call next() to hand off to the next middleware. Forgetting both is the most common mistake when starting with Express.

References

Express docs — Writing middleware

Question 18Express

What is express.Router() typically used for?

A.Generating CRUD routes automatically from a model definition
B.Grouping routes per module and mounting them into the app
C.Creating a second HTTP server running alongside the main app
D.Load-balancing requests across several Node processes

Answer: B

Grouping routes by module/domain — users.routes.js holds all user routes, then app.use('/users', usersRouter). A router behaves like a mini-app: its own middleware, its own routes, keeping app.js from bloating into a route list hundreds of lines long.

References

Express docs — Routing (express.Router)

Question 19NestJS

In NestJS, how do controllers and providers differ?

A.The provider receives the HTTP request and injects the controller to handle it
B.The controller takes the request and returns the response while the provider holds the logic and is injected
C.The controller holds the business logic while the provider only declares routes
D.They are two names for the same kind of class

Answer: B

A controller (decorator @Controller) receives HTTP requests, reads params/body, and returns responses — the thinner the better. A provider (usually a service, decorator @Injectable) holds business logic and is injected into controllers. Both are registered in a module — Nest's unit of packaging by domain.

References

NestJS docs — Providers

Question 20Operations

How should you choose a Node.js version for production?

A.The newest version, for all the latest features
B.A long-term support version still within its patch window
C.The version already installed on your personal machine
D.The oldest version that still runs, for stability

Answer: B

A long-term support version still within its security patch window. Odd-numbered releases live only a few months and don't get long-term security patches, so they are meant for trying out new features.

References

Node.js — Release schedule

Intermediate level — 55 Node.js questions

Question 1Event Loop

Microtask vs `setTimeout` — what does this code print?

javascript

console.log('start')
setTimeout(() => console.log('timeout'), 0)
Promise.resolve().then(() => console.log('promise'))
console.log('end')

A.start end promise timeout
B.start end timeout promise
C.start timeout promise end
D.start promise timeout end

Answer: A

Prints start end promise timeout. Synchronous code runs to completion first; then the microtask queue (promise) is fully drained before the event loop handles the macrotask (setTimeout), even with a delay of 0. (FREE)

References

Question 2Timers

A microtask between two timers — what does this code print?

javascript

setTimeout(() => {
  console.log('timer1')
  Promise.resolve().then(() => console.log('micro'))
}, 0)
setTimeout(() => console.log('timer2'), 0)

A.timer2 timer1 micro
B.timer1 micro timer2
C.timer1 timer2 micro
D.micro timer1 timer2

Answer: B

timer1, micro, timer2. Both timers have the same delay and run in registration order, but the microtask queue is drained after EACH callback — it doesn't wait for the whole timers batch — so micro slips between the two timers. (FREE)

References

Question 3Modules

The `require` cache — given these two CommonJS files, what does `node main.js` print?

// counter.js
let count = 0
module.exports = { increment: () => ++count }

// main.js
const c1 = require('./counter')
const c2 = require('./counter')
c1.increment()
c1.increment()
console.log(c2.increment())

Answer: C

3. require caches modules by resolved path: the file runs only once, and every later require returns the same exports object. c1 and c2 share the count variable, so the three increments accumulate to 3. (FREE)

References

Question 4Modules

`exports` vs `module.exports` — given these two CommonJS files, what does `node main.js` print?

// lib.js
exports.a = 1
module.exports = { b: 2 }

// main.js
const lib = require('./lib')
console.log(lib.a, lib.b)

A.undefined 2
B.1 undefined
C.1 2
D.undefined undefined

Answer: A

undefined 2. exports is just an alias variable pointing to the original module.exports. Assigning module.exports = {...} replaces it with a NEW object; the a property set on the old object is dropped. require always returns the final module.exports. (FREE)

References

Question 5Streams & Buffer

`subarray` shares memory — what does this code print?

javascript

const buf = Buffer.from('abc')
const view = buf.subarray(0, 2)
view[0] = 120
console.log(buf.toString())

A.xb
B.120bc
C.xbc
D.abc

Answer: C

xbc. subarray returns a VIEW that shares memory with the original buffer, not a copy. Assigning view[0] = 120 writes directly to the first byte of buf — 120 is the ASCII code for "x", so buf.toString() becomes "xbc". (FREE)

References

Question 6Process & Env

`process.env` coerces every value to a string — what does this code print?

javascript

process.env.FLAG = false
if (process.env.FLAG) {
  console.log('on')
} else {
  console.log('off')
}
console.log(typeof process.env.FLAG)

A.off boolean
B.on string
C.on boolean
D.off string

Answer: B

on then string. process.env is a bridge to the OS environment variables, so every value assigned to it is coerced to a STRING — false becomes "false". A non-empty string is always truthy, so the if takes the on branch. (FREE)

References

Node.js docs — process.env

Question 7Event Loop

How do `process.nextTick()` and `setImmediate()` differ in when their callbacks run?

A.The two are equivalent, differing only in syntax
B.A process.nextTick callback runs right after the current operation, before the event loop continues
C.setImmediate runs immediately in the same tick while process.nextTick waits for the next loop
D.process.nextTick runs its callback on another thread so as not to block the main one

Answer: B

process.nextTick(cb) puts the callback on a queue that is drained right after the current operation, BEFORE the event loop moves to the next phase — it even runs ahead of Promise microtasks in Node's processing order. setImmediate(cb) runs in the check phase, after the poll phase. Because nextTick cuts in ahead of every phase, recursive nextTick calls can starve I/O; the docs recommend preferring setImmediate when possible.

References

Question 8Modules

What does this program print, and why?

javascript

// counter.js
let count = 0
module.exports = { increment: () => ++count }

// app.js
const a = require('./counter')
const b = require('./counter')
a.increment()
console.log(b.increment())

A.It prints 2 — the module is cached after the first require, so a and b are one and the same
B.An error — the same file may not be required twice in one module
C.It prints undefined — an arrow function cannot access the module-scope count
D.It prints 1 — each require loads a fresh copy of the module with its own count

Answer: A

It prints 2. CommonJS modules are cached by resolved path: the first require executes counter.js and stores module.exports in require.cache; the second returns that same object. a and b are the same instance, so both increment() calls bump the same count variable → 1 then 2.

References

Node.js — Modules: Caching

Question 9Worker Threads

How do the `cluster` and `worker_threads` modules differ in Node.js, and when do you use each?

A.cluster creates lightweight threads sharing memory with the main process, making it cheaper than worker_threads
B.worker_threads lets several threads listen on one port while cluster cannot
C.They are the same module; worker_threads is just the new name for cluster
D.cluster forks several Node PROCESSES that can share a server port

Answer: D

cluster forks multiple child Node processes — each worker has its own event loop, V8, and memory — and lets them share the same server port to use multiple cores for I/O workloads (HTTP servers). worker_threads creates threads within the same process, communicating via messages and able to share memory (SharedArrayBuffer); the docs state it's suited to CPU-intensive tasks and doesn't help much for I/O.

References

Question 10Process & Env· select all that apply

Which statements are TRUE about `spawn()`, `exec()`, and `fork()` in the `child_process` module? (select all that apply)

A.fork() is for running arbitrary shell commands with better performance than spawn()
B.exec() runs a command in a shell and buffers the entire output, delivering it once through a callback; output beyond maxBuffer errors
C.spawn() returns stdout/stderr as streams without buffering the whole output
D.exec() is best for large output because it streams the data chunk by chunk
E.fork() is a variant of spawn dedicated to running another Node.js file, with an IPC channel set up for parent–child send() messages

Answer: B, C, E

All three belong to child_process and differ in how they return results: spawn returns output as a stream, no buffering — good for large data; exec runs through a shell and buffers the entire output, returning it once via callback (maxBuffer limit ~1MB); fork is a spawn specialized for Node.js files, with a built-in IPC channel for send() messages. Mnemonic: spawn = stream, exec = buffer + shell, fork = spawn Node with IPC.

References

Node.js — Child process

Question 11Event Loop

`setImmediate` vs `setTimeout` in an I/O callback — what does this code print?

javascript

const fs = require('node:fs')
fs.readFile(__filename, () => {
  setTimeout(() => console.log('timeout'), 0)
  setImmediate(() => console.log('immediate'))
})

A.immediate timeout
B.timeout immediate
C.The order varies between runs and is not deterministic
D.(nothing is printed)

Answer: A

It prints immediate then timeout. The fs callback runs in the poll phase; the event loop moves on to the check phase — where setImmediate runs — before the next iteration loops back to the timers phase for setTimeout(0). Inside an I/O callback this order is deterministic; at the top level it isn't.

References

Question 12Events

EventEmitter `once` vs `on` — what does this code print?

javascript

const { EventEmitter } = require('node:events')
const emitter = new EventEmitter()
emitter.once('greet', name => console.log('once:', name))
emitter.on('greet', name => console.log('on:', name))
emitter.emit('greet', 'a')
emitter.emit('greet', 'b')

A.once: a on: a
B.once: a on: a once: b on: b
C.once: a on: a on: b
D.on: a once: a on: b

Answer: C

Prints once: a, on: a, on: b. emit calls listeners SYNCHRONOUSLY in registration order, so the first emit runs both. A listener registered with once removes itself after the first call; on the second emit only the on listener is left. (FREE)

References

Question 13Core APIs

`structuredClone` vs `JSON.parse(JSON.stringify())` — what does this code print?

javascript

const data = { date: new Date(0), tags: new Set(['a']) }
const viaJson = JSON.parse(JSON.stringify(data))
const viaClone = structuredClone(data)
console.log(viaJson.date instanceof Date, viaClone.date instanceof Date)
console.log(viaJson.tags instanceof Set, viaClone.tags instanceof Set)

A.An error, because JSON.stringify cannot handle a Set
B.true true true true
C.false true false false
D.false true false true

Answer: D

Prints false true both times. JSON.parse(JSON.stringify(...)) loses types: Date becomes an ISO string, Set becomes an empty {}. structuredClone uses the structured clone algorithm — it supports Date, Set, Map, ArrayBuffer... — so the copy keeps instanceof intact. (FREE)

References

Question 14Event Loop

Which operations in Node.js actually run on the libuv thread pool (4 threads by default)?

A.Filesystem (fs.*), dns.lookup(), and the CPU-heavy crypto/zlib functions (pbkdf2, scrypt, compression)
B.Every asynchronous I/O operation, HTTP requests and TCP sockets included, is handed to the thread pool
C.The thread pool runs JavaScript callbacks in parallel so several handlers execute at once
D.The thread pool only activates when using worker_threads; the fs/crypto APIs run on the main thread by default

Answer: A

The libuv thread pool (4 by default, tuned via UV_THREADPOOL_SIZE, max 1024) runs operations with NO non-blocking OS API: filesystem (fs.*), dns.lookup(), and the heavy computation parts of crypto (pbkdf2, scrypt, async randomBytes) plus zlib. Network I/O does NOT go through the pool — sockets are watched by the kernel via epoll/kqueue/IOCP right on the event loop thread.

References

Question 15Streams & Buffer· select all that apply

Which statements are TRUE when comparing `stream.pipeline()` with `.pipe()`? (select all that apply)

A.pipeline is significantly slower because it copies data through an intermediate buffer between each pair of streams
B.When one stream in the chain errors, pipeline destroys all the remaining streams, avoiding file descriptor leaks; .pipe() leaves the destination stream alive
C.There is a Promise version in stream/promises: await pipeline(src, transform, dest) works directly with async/await and try/catch
D..pipe() manages backpressure while pipeline does not, so large files require .pipe()
E.pipeline funnels errors from every stream in the chain into one callback/Promise; .pipe() requires manually attaching an error listener to each stream.

Answer: B, C, E

stream.pipeline() = .pipe() plus two things .pipe() lacks: (1) errors from every stream in the chain are collected into a single callback/Promise — pipe does not propagate errors, you must attach listeners per stream; (2) on error the whole chain is destroyed, so no file descriptors leak. Backpressure is the same in both. New code should use the Promise version from stream/promises with async/await.

References

Question 16HTTP

What does Express add over Node's built-in `http` module?

A.Running on several threads to use all the server's CPU cores
B.HTTPS support that the core module does not provide
C.Routing, middleware and conveniences for the request and response
D.The ability to handle many concurrent connections that the core module lacks

Answer: C

Path- and method-based routing, middleware chaining, and conveniences like reading parameters, sending JSON, and serving static files. The core module provides only a single handler function that receives the raw request and response.

References

Node.js docs — HTTP

Question 17HTTP

What happens when an Express middleware never calls `next()`?

A.The next middleware still runs but without the data already processed
B.The request hangs until it times out, unless a response was already sent
C.The request gets a 500 with a message about the failing middleware
D.The framework moves on to the next middleware automatically after a delay

Answer: B

The chain stops there. If the middleware also hasn't sent a response, the request hangs until the client or proxy times out. This is a common bug in conditional branches: the main branch calls the next function but the other branch forgets to.

References

Node.js docs — HTTP

Question 18HTTP

Why is `req.body` undefined when a client sends JSON to an Express server?

A.Because the request's method does not allow a body
B.Because the body exceeds the framework's default size limit
C.Because no body-parsing middleware has been registered
D.Because the client did not set the correct content-type header

Answer: C

Because no body-parsing middleware is registered. The request body arrives as a raw data stream — Node doesn't read and parse it on its own. You have to register the appropriate middleware before the routes, and it only processes when the content-type header matches.

References

Node.js docs — HTTP

Question 19Security

Who does configuring CORS on a Node server protect?

A.The server, by blocking requests from disallowed origins
B.Data in transit, by requiring the connection to be encrypted
C.Both, because the server refuses to process a request whose origin header does not match
D.Users, and the enforcement happens in the browser rather than on the server

Answer: D

It protects the user, and enforcement happens in the browser. The server only sends headers declaring which origins may read the response. A command-line tool or another backend can still call the API normally since they don't apply the browser's rules.

References

Node.js docs — Security best practices

Question 20Streams & Buffer

What is wrong with sending a 2 GB file by reading it entirely into memory first?

A.Node does not allow a response larger than a fixed threshold
B.The connection closes because reading the file exceeds the timeout
C.The process may run out of memory, and the client waits until the whole read finishes
D.The file is corrupted because it exceeds a buffer's maximum size

Answer: C

The entire 2 GB sits in process memory at once — a few concurrent requests and you're out of memory. The client also has to wait until the read finishes before receiving the first byte. With streams, data flows gradually and memory holds only a small chunk.

References

Node.js docs — Stream

Question 21Security

Where is rate limiting on a Node API most effective?

A.Only in the application, since that is where the business rules live
B.At the database layer, since it is the scarcest resource
C.At the edge layer first, plus a per-account layer inside the application
D.Only at the edge, since that is the cheapest place to refuse a request

Answer: C

Both layers. The edge or CDN layer blocks raw traffic by IP address before it consumes Node process resources. The application layer adds per-account or per-API-key limits — things the edge layer does not know about.

References

Node.js docs — Security best practices

Question 22Security

How should secrets be stored for a Node application in production?

A.An encrypted config file committed with the source for deployment convenience
B.Constants in the code but in a separate file so they are easy to find and change
C.Environment variables or a secrets manager, never committed to the repo
D.The application's database, to manage them centrally in one place

Answer: C

Environment variables for simple cases, and a dedicated secret management store for larger systems. The hard rule is never commit them to a repository — a secret that has entered Git history must be revoked, not just deleted.

References

Node.js docs — Security best practices

Question 23Package Management

Which versions does `"express": "^4.18.0"` allow?

A.Exactly version 4.18.0 and nothing else
B.Any 4.x version from 4.18.0 upwards, but not 5.x
C.Only patch versions from 4.18.0 through 4.18.x
D.Every version from 4.18.0 upwards, newer major versions included

Answer: B

Any 4.x version from 4.18.0 upward — minor and patch updates are allowed, but not 5.x. The tilde is stricter, allowing only patch updates within the same minor version.

References

npm docs — package.json

Question 24Package Management

How does `npm ci` differ from `npm install`?

A.It skips packages' lifecycle scripts for safety
B.It installs only the production dependencies
C.It installs in parallel and so is much faster on a multi-core machine
D.It installs exactly per the lockfile and never modifies it

Answer: D

It installs exactly according to the lock file and never modifies that file — if the lock file is missing or out of sync with the manifest, it fails instead of fixing it. It also wipes the dependencies directory before installing, so the result is always identical.

References

npm docs — package.json

Question 25Package Management

What do `peerDependencies` declare?

A.Packages needed only when running this package's own tests
B.That this package needs another package supplied by the host application
C.Equivalent packages that can substitute for each other at install time
D.Packages installed in parallel to shorten the install time

Answer: B

That this package needs another package, but that version must be installed by the host application rather than by the package itself. This is how a plugin ensures it uses the same version of a library as the application — for example, a React plugin must share the React version the application is running.

References

npm docs — package.json

Question 26Testing

Since which version does Node ship a built-in test runner, and how is it used?

A.Since Node 16, but it only supports synchronous tests
B.Node has no test runner; an external library is always required
C.Since Node 14, but it only runs files with a special extension
D.Since Node 18 (stable in Node 20), run with the test command and the node:test module

Answer: D

Since Node 18 as experimental and stable in Node 20. Import from the node:test module, use it with the built-in assertion module, then run with Node's test command. No extra dependencies needed — good for libraries that want to keep their dependency tree lean.

References

Node.js docs — Test runner

Question 27Testing

When testing a module that calls an external API, which approach gives the most stable tests?

A.Intercept at the network layer with a mock server
B.Call the real API to be sure the result matches reality
C.Replace the network-calling function with a stub returning fixed data
D.Skip testing the API call and test only the data processing

Answer: A

Intercept at the network layer with a mock server. This lets the code under test run intact — including path construction, headers, and response parsing — so the tests verify more and break less during refactoring.

References

Node.js docs — Test runner

Question 28Tooling

What does Node's `--watch` flag do?

A.It restarts the process automatically when a source file changes
B.It reloads only the changed module without restarting the process
C.It monitors memory usage and warns when a threshold is passed
D.It opens a debug port for a debugger to attach to

Answer: A

Automatically restarts the process when source files change — replacing the need to install an external tool for this. Available since Node 18 as experimental and stable in Node 22, with a separate flag to watch additional specific paths.

References

Node.js docs — CLI

Question 29Performance

What does event loop lag measure and why does it matter?

A.The number of tasks waiting in the event loop's queue
B.The average time to finish handling one HTTP request
C.The interval between two garbage collector runs
D.The delay between a task being scheduled and actually running

Answer: D

The delay between when a task is scheduled and when it actually runs. A high value means the main thread is being held by some task — so every request is slow even though CPU usage looks normal.

References

Node.js docs — Performance measurement APIs

Question 30Modern Node

Why write `require("node:fs")` instead of `require("fs")`?

A.To state explicitly that this is a core module, which no same-named package can displace
B.To use a newer version of the module instead of an older one
C.To load the module faster by skipping the lookup step
D.To make core modules work in an ES Module context

Answer: A

To make it explicit that this is a Node core module. Without the prefix, a package in the dependency tree with the same name as the core module could be loaded instead — both a security risk and a source of confusion. With the prefix, Node always loads the core module.

References

Node.js docs — ECMAScript modules

Question 31Modern Node

Where can top-level await be used in Node?

A.In any JavaScript file from Node 14 onwards
B.Only in files with a special extension dedicated to this feature
C.Only inside a try/catch block at the top level of the file
D.Only in ES Modules, never in CommonJS

Answer: D

Only in ES Modules. The CommonJS loading model is synchronous — the load call must return a value immediately — so there is no room for pausing. ES Modules load asynchronously by design, so they support it.

References

Node.js docs — ECMAScript modules

Question 32Core APIs

You need a random string as a token. Which API should you use?

A.Math.random() combined with the current timestamp
B.An incrementing counter encoded into a higher base
C.crypto.randomBytes() or crypto.randomUUID()
D.A hash of the timestamp and the process id

Answer: C

The functions in the crypto module — generate random bytes, or generate a version 4 unique identifier. They draw from the operating system's cryptographically secure random source. JavaScript's ordinary random function is not safe for this purpose.

References

Node.js docs — API reference

Question 33Database

Why should a Node application use a connection pool rather than opening a new connection per request?

A.Because a pool compresses the data travelling between application and database
B.Because opening a connection costs several round trips and the database has a connection limit
C.Because a pool retries failed queries automatically after a network error
D.Because a pool guarantees every query runs in the same transaction

Answer: B

Because opening a connection costs a network handshake plus authentication — tens of milliseconds per request. And the database has a limit on concurrent connections: exceed it and it refuses to serve. A pool keeps a number of connections ready and rotates them among the queries that use them.

References

node-postgres — Connection pooling

Question 34Database

What must you watch for when running a transaction with a connection pool?

A.The highest isolation level must be set to avoid data conflicts
B.The transaction must run in a separate process to avoid blocking
C.Every statement must run on the same connection taken from the pool
D.The connection must be closed after the transaction rather than returned to the pool

Answer: C

Every statement in the transaction must run on the same connection. A transaction is state of a specific connection, so if you call queries through the pool object, each call may get a different connection — and those statements end up outside the transaction.

References

node-postgres — Connection pooling

Question 35Operations

Why should a production Node application run behind a process manager?

A.To encrypt the traffic between the application and the connecting clients
B.To speed up JavaScript execution through cache optimisation
C.To update dependency packages automatically when new versions appear
D.To restart when the process dies and to run several processes across the cores

Answer: D

Two main reasons: automatic restart when the process dies from an uncaught exception, and running multiple processes to use all CPU cores — because a single Node process uses only one core for JavaScript code.

References

Node.js docs — Cluster

Question 36Operations

Why prefer structured (JSON) logging over free-text strings?

A.So logs are written faster by skipping string formatting
B.To reduce log size because JSON compresses better than plain text
C.So the system classifies each line's severity automatically
D.So it can be queried and filtered by field in the log collection system

Answer: D

So log collectors can query and filter by individual fields — find every request from one user, filter by error code, compute response-time percentiles. With free-text strings, you have to extract data with regex, which breaks the moment someone rewords the message.

References

Node.js docs — Cluster

Question 37Operations

What should a health check endpoint verify?

A.Simply returning a 200 to confirm the process is running
B.The essential dependencies, with the liveness check separated from the readiness check
C.Every service the application might call, optional ones included
D.CPU and memory usage against configured thresholds

Answer: B

Essential dependencies — database, queue — and it should be split into two types. A liveness check only confirms the process isn't hung, and is used to decide whether to restart. A readiness check confirms it can serve, and is used to decide whether to send traffic to it.

References

Node.js docs — Cluster

Question 38Operations

What is the purpose of a multi-stage build in a Dockerfile for a Node application?

A.So each stage runs on a different Node version
B.To cache each layer so the build does not start from scratch each time
C.To build several components in parallel and shorten the build
D.So the final image holds only the built code and runtime dependencies, without the build tools

Answer: D

So the final image contains only the built code and runtime dependencies — no compiler, source code, or dev dependencies. A much smaller image means faster pulls, faster startup, and a smaller attack surface.

References

Node.js docs — Cluster

Question 39Modern Node

Since which version does Node ship a built-in `fetch`?

A.Node 16, but only usable in ES Modules
B.Node 14, at the same time as ES Module support
C.Node has never shipped one; an external library is always required
D.Node 18 (experimental) and stable in Node 21

Answer: D

Node 18 as experimental and stable from Node 21. It uses a next-generation HTTP library underneath, so its behaviour matches the browser API of the same name — no external library needed for ordinary HTTP calls anymore.

References

Node.js docs — ECMAScript modules

Question 40Modern Node

How do you set a timeout on a `fetch` call in Node?

A.Pass an AbortSignal with a deadline into the signal option
B.Configure a global timeout through a Node environment variable
C.Pass a number of milliseconds to the call's timeout option
D.Wrap the call in a race against a promise that waits for a period

Answer: A

Pass an abort signal with a timeout into the corresponding option — there's a built-in constructor that takes milliseconds. The wrap-it-in-a-race-with-a-timer-promise approach is wrong because the real request keeps running and still holds the connection.

References

Node.js docs — ECMAScript modules

Question 41HTTP

Where should HTTP response compression (gzip or brotli) be enabled?

A.On the client side, by asking the browser to decompress
B.At the reverse proxy or CDN in front, not in the Node process
C.In the Node process, for precise control of the compression level per content type
D.In both places to be sure the response is always compressed

Answer: B

At the reverse proxy or CDN in front. Compression costs CPU and uses resources of the application process/libuv thread pool, which can compete with application work and add latency; the edge tier usually handles, caches, and scales this part better.

References

Node.js docs — HTTP

Question 42Security

Where and how should API input validation be done?

A.In every function that uses the data, to be sure nothing is missed
B.At the database layer, relying on the table schema's constraints
C.At the entry boundary, with a declarative schema, rejecting early
D.On the client, since that is where the user enters the data

Answer: C

At the application's ingress boundary, using a declarative schema — validate as soon as the request arrives and reject with a clear message if it's invalid. Past that boundary, the inner layers trust the validated data and don't have to defend against it again.

References

Node.js docs — Security best practices

Question 43Performance

What problem does `JSON.stringify()` on a very large object cause?

A.It compresses the result automatically, changing the data's format
B.It runs synchronously and so blocks the main thread for the whole duration
C.It throws when the result exceeds the maximum string size
D.It skips properties nested beyond a certain depth

Answer: B

It runs synchronously, so it blocks the main thread for the whole process. For an object of tens of megabytes this takes hundreds of milliseconds — during which no other request is handled and event loop latency spikes.

References

Node.js docs — Performance measurement APIs

Question 44Architecture

Which folder structure ages better for a mid-sized Node service?

A.Every file at the root, distinguished by a prefix in the filename
B.By technical layer, with each layer as its own package
C.By file kind: a controllers folder, a services folder, a models folder
D.By feature, each folder holding its routes, logic and data access

Answer: D

Organize by feature: each folder holds the routes, business logic, data access, and tests for that feature. A business change touches only one folder instead of four separate ones as in a file-type-based layout.

References

Node.js docs — Event loop, timers, nextTick

Question 45Performance

What should you consider first when adding a cache layer in front of a database?

A.How much memory to allocate to the cache layer
B.The serialisation format for storing values in the cache
C.Whether to use an in-process cache or a centralised one
D.How stale the data may be, and how it will be refreshed

Answer: D

How much stale data you can accept. A cache always trades freshness for speed, so decide per data type up front: a product catalog that is a few minutes old is fine, an account balance is not.

References

Node.js docs — Performance measurement APIs

Question 46Core APIs

What does `os.cpus().length` report inside a container?

A.Always 1, since Node runs JavaScript on one thread
B.The physical host's core count rather than the container's CPU limit
C.The number of cores the Node process is actually using at that moment
D.The CPU limit allocated to the container, rounded up

Answer: B

The number of cores of the physical server, not the container's CPU quota. A container allocated one core on a 64-core machine still reports 64 — so using it to size worker processes multiplies your actual allowance many times over.

References

Node.js docs — API reference

Question 47Express

How does Express recognize a middleware as an error handler?

A.The function's or variable's name contains "error"
B.Standing immediately after the route that throws
C.The function declares exactly 4 parameters (err, req, res, next)
D.Registering it through app.error() instead of app.use()

Answer: C

It is based on the number of parameters: a function with exactly 4 parameters (err, req, res, next) is treated as an error handler. So you must keep all 4 even if next is unused — dropping one makes Express treat it as regular middleware. Error handlers should be registered last, after all routes.

References

Express docs — Error handling

Question 48Express

Running on Express 4, what happens when db.findUser rejects?

app.get('/users/:id', async (req, res) => {
  const user = await db.findUser(req.params.id) // may reject
  res.json(user)
})

A.Express retries the handler once before reporting an error
B.The 4-parameter error handler receives the error as it would a synchronous one
C.Express returns a 500 with the error details to the client
D.The promise rejection becomes unhandled rejection, and the request hangs without a response

Answer: D

Express 4 does not catch async errors: a rejected promise never reaches the error handler; Express sends no response and the rejection becomes an unhandled rejection, which can terminate the process depending on the Node version/configuration. You must try/catch yourself and call next(err) (or use .catch(next)). Express 5 does catch rejected promises from handlers and forwards them to error middleware.

References

Express docs — Catching errors

Question 49Express

Which requests does app.use('/api', router) match?

A.Also /apiv2, since it starts with the characters /api
B.Every path containing the string "api" anywhere
C.Only /api exactly — sub-paths must each be mounted separately
D./api and every sub-path of the form /api/...

Answer: D

It matches /api and every child path such as /api/users, /api/users/1... — the mount path is a segment prefix, not raw string comparison, so /apiv2 does NOT match. Inside the router, paths are computed relatively: router.get('/users') corresponds to /api/users.

References

Express docs — app.use()

Question 50Express

This code logs "Cannot set headers after they are sent to the client". Why?

app.get('/orders/:id', (req, res, next) => {
  res.json({ ok: true })
  next()
})

app.use((req, res) => {
  res.status(404).json({ error: 'Not found' })
})

A.A missing return before res.json makes Express send the response twice
B.next() passes the request on and the 404 middleware sends a second response
C.res.json must be the last statement in the handler
D.res.status must be called before res.json within one middleware

Answer: B

The handler already sent a response with res.json but still called next(), so the request continued to the 404 middleware — which calls res.status(404).json(...) a second time on an already sent response. Rule: send a response only once per request; once sent, do not call next().

References

Express docs — The default error handler

Question 51NestJS

By what mechanism does OrdersController receive an OrdersService instance without newing it?

@Injectable()
export class OrdersService {}

@Controller('orders')
export class OrdersController {
  constructor(private readonly ordersService: OrdersService) {}
}

A.Nest's DI container creates the instance and passes it to the constructor
B.Nest scans the directory and matches a service whose filename matches the controller's
C.The @Controller decorator instantiates every class marked @Injectable()
D.TypeScript instantiates readonly parameters at compile time

Answer: A

Nest's Dependency Injection container. Using the type metadata TypeScript emits, Nest knows the constructor needs OrdersService, finds that provider in the module, creates (or reuses) the instance, and passes it in. Requirements: the service is decorated with @Injectable() and declared in the module's providers.

References

NestJS docs — Dependency injection fundamentals

Question 52NestJS

Which order is correct in the NestJS request lifecycle?

A.Pipes → Guards → Middleware → Handler → Interceptors
B.Guards → Middleware → Pipes → Interceptors → Handler
C.Middleware → Pipes → Guards → Handler → Interceptors
D.Middleware → Guards → Interceptors → Pipes → Handler

Answer: D

Middleware → Guards → Interceptors (before) → Pipes → Handler → Interceptors (after) → Exception filters (on error). Key point: guards run BEFORE pipes — rejecting unauthorized requests before validation; interceptors wrap the handler so they run on both sides.

References

NestJS docs — Request lifecycle

Question 53NestJS

A guard's canActivate returns false. What does the client receive?

A.401 Unauthorized
B.403 Forbidden
C.500 Internal Server Error because a guard must throw rather than return false
D.The request still reaches the handler but carries a rejected flag

Answer: B

403 Forbidden — Nest throws ForbiddenException automatically when a guard returns false, and the handler does not run. To return a different code (e.g. 401 for a missing token), the guard must explicitly throw new UnauthorizedException() instead of returning false.

References

NestJS docs — Guards

Question 54NestJS

ValidationPipe has whitelist: true. What happens to body fields not declared in the DTO?

A.Those fields are stripped from the object before the handler
B.The unknown fields move to req.rawBody for separate handling
C.It returns 400 immediately because the body contains invalid fields
D.It keeps the fields and writes a warning to the log

Answer: A

Unknown fields are stripped before the object reaches the handler — only fields with class-validator decorators in the DTO are kept. To get a 400 error instead of silent removal, also enable forbidNonWhitelisted: true. This is the mass-assignment defense: a client can't inject isAdmin: true into the body.

References

NestJS docs — Validation

Question 55NestJS

A NestJS handler throws new NotFoundException(). What happens next?

A.An exception filter catches it and returns a standard JSON 404
B.The process crashes because nobody catches the exception
C.The error falls through to a 4-parameter error middleware as in Express
D.A downstream interceptor turns it into a 200 with an empty body

Answer: A

The default exception filter catches it and returns { "statusCode": 404, "message": "Not Found" }. Any HttpException (NotFoundException, BadRequestException...) is turned into a response with the right status code; a non-HttpException returns 500 "Internal server error" and hides the details.

References

NestJS docs — Exception filters

25 more Advanced questions for Node.js

Advanced goes deep on real-world scenarios and the technical pitfalls candidates actually run into. Included with Pro.

Upgrade to Pro

Node.js quiz — 75 questions with answers and explanations

20 Beginner · 55 Intermediate

Try Node.js quiz

What the Node.js quiz covers

Express7
Core APIs6
NestJS6
Event Loop5
Operations5
Streams & Buffer5
HTTP4
Modern Node4
Modules4
Package Management4
Process & Env4
Security4
Performance3
Database2
Promises & Async2
Testing2
Timers2
Architecture1
Error Handling1
Events1
Tooling1
Operations1
Worker Threads1

Want long-form answers? Read 89 Node.js interview questions with answers — same topic, in more depth.

Beginner level — 20 Node.js questions

Question 1Timers

`clearTimeout` right after `setTimeout` — what does this code print?

javascript

const timer = setTimeout(() => console.log('tick'), 0)
clearTimeout(timer)
console.log('done')

A.done
B.done tick
C.(nothing is printed)
D.tick done

Answer: A

References

Question 2Promises & Async

What an `async` function returns — what does this code print?

javascript

async function getValue() {
  return 1
}
console.log(getValue())

A.undefined
B.Promise { 1 }
C.1
D.[object Promise]

Answer: B

References

Question 3Streams & Buffer

`Buffer.length` vs `String.length` — what does this code print?

javascript

const buf = Buffer.from('hé')
console.log(buf.length, 'hé'.length)

A.3 2
B.2 2
C.2 3
D.3 3

Answer: A

References

Question 4Event Loop

Node.js is described as "single-threaded" — what does that actually mean?

A.Single-threaded means Node can only handle one request at a time
B.Node.js is multithreaded: each request gets its own thread to run JavaScript on
C.The application's JavaScript runs on a single thread with an event loop
D.A Node process has exactly one OS thread, I/O included

Answer: C

References

Question 5Modules

What is the fundamental difference between `require()` (CommonJS) and `import` (ES Modules) in Node.js?

A.require loads a module synchronously at runtime and can be called anywhere
B.import is just another spelling of require with identical behaviour
C.require runs asynchronously and returns a Promise, so it needs await require(...)
D.Node.js cannot run ES Modules; import only works in browsers

Answer: A

References

Question 6Error Handling

What is the "error-first callback" convention in Node.js?

A.The callback takes the error as its FIRST parameter ((err, data) => {})
B.Each API takes two separate callbacks: one for success and one for failure
C.The error is the callback's last parameter so it is easy to ignore when unneeded
D.Errors in an async callback are thrown and caught by a try/catch around the function call

Answer: A

References

Question 7Promises & Async

`Promise.allSettled` — what does this code print?

javascript

Promise.allSettled([
  Promise.resolve(1),
  Promise.reject(new Error('boom')),
]).then(results => {
  for (const r of results) console.log(r.status)
})

A.fulfilled rejected
B.rejected fulfilled
C.fulfilled
D.Uncaught Error: boom

Answer: A

References

Question 8Process & Env

When implementing graceful shutdown for a Node.js server, which statement about the SIGTERM and SIGKILL signals is TRUE?

A.SIGTERM can be caught with process.on('SIGTERM', ...) to close the server, drain in-flight requests and exit; SIGKILL accepts no listener
B.The standard approach is calling process.exit(0) on the first line of the SIGTERM handler to exit as fast as possible
C.Node shuts down gracefully on SIGTERM by itself: it waits for in-flight requests before exiting, with no extra code needed
D.SIGKILL can also be caught with process.on('SIGKILL', ...) like any other signal, as long as you register early

Answer: A

References

Question 9Process & Env

A Node app reads `process.env.DATABASE_URL` but gets `undefined`. Most common cause?

A.Node only reads fully uppercase environment variables
B.The variable's type must be declared in package.json before it can be read
C.process.env only works in CommonJS and not with ESM
D.The variable was never loaded into the process — Node does not read a .env file by itself

Answer: D

References

Node.js docs — process

Question 10Core APIs

Why use `path.join()` instead of concatenating paths with `/`?

A.It is mandatory when working with the fs module
B.It uses the operating system's correct separator and normalises the path
C.It is faster than string concatenation because it is optimised in C++
D.It creates the directory automatically when the path does not exist

Answer: B

References

Node.js docs — path

Question 11Core APIs

Why avoid `fs.readFileSync()` inside a request handler?

A.Because it cannot handle the error when the file does not exist
B.Because it cannot read large files
C.Because it blocks the main thread so every other request has to wait
D.Because it reads more slowly than the asynchronous version of the same operation

Answer: C

References

Node.js docs — API reference

Question 12Package Management

How do `dependencies` and `devDependencies` differ in package.json?

A.The second group can only be used in scripts and cannot be imported
B.The second group is not pinned to exact versions in the lockfile
C.The second group is only needed during development and is not installed for production
D.The second group is installed first so the main packages can use it

Answer: C

References

npm docs — package.json

Question 13Core APIs

Is `__dirname` available in a Node ES Module file?

A.Yes, but its value is always the project root
B.No; it must be derived from import.meta.url or import.meta.dirname
C.No, and there is no way to obtain the directory path at all
D.Yes, but a compatibility flag must be enabled when running Node

Answer: B

References

Node.js docs — API reference

Question 14Streams & Buffer

What encoding does `buf.toString()` use with no argument?

A.An encoding inferred automatically from the buffer's contents
B.ASCII, so accented characters are lost
C.Base64, being the safest way to display bytes
D.UTF-8

Answer: D

UTF-8. This is the default for every conversion between strings and bytes in Node. Other encodings — hex, base64, latin1 — must be specified explicitly as an argument.

References

Node.js docs — Stream

Question 15Operations

What does the `NODE_ENV=production` variable affect?

A.Many libraries read it to disable checks and enable optimisations
B.Node stops writing to the console to reduce I/O cost
C.Node installs only the production dependencies at startup
D.Node enables optimisations and disables type checking when compiling

Answer: A

References

Node.js docs — Cluster

Question 16Express

In Express, what determines the order in which middleware run?

A.Express sorts them itself: the body parser always runs before the route handler
B.A more specific path takes precedence and runs first
C.The registration order through app.use / app.get and so on
D.The priority declared in each middleware's options

Answer: C

References

Express docs — Using middleware

Question 17Express

An Express middleware neither calls next() nor sends a response. What happens to the request?

A.It hangs until the client times out
B.Express returns 404 because no route finished handling the request
C.Express moves to the next middleware after a default wait
D.Express throws a warning that the middleware forgot to call next()

Answer: A

References

Express docs — Writing middleware

Question 18Express

What is express.Router() typically used for?

A.Generating CRUD routes automatically from a model definition
B.Grouping routes per module and mounting them into the app
C.Creating a second HTTP server running alongside the main app
D.Load-balancing requests across several Node processes

Answer: B

References

Express docs — Routing (express.Router)

Question 19NestJS

In NestJS, how do controllers and providers differ?

A.The provider receives the HTTP request and injects the controller to handle it
B.The controller takes the request and returns the response while the provider holds the logic and is injected
C.The controller holds the business logic while the provider only declares routes
D.They are two names for the same kind of class

Answer: B

References

NestJS docs — Providers

Question 20Operations

How should you choose a Node.js version for production?

A.The newest version, for all the latest features
B.A long-term support version still within its patch window
C.The version already installed on your personal machine
D.The oldest version that still runs, for stability

Answer: B

References

Node.js — Release schedule

Intermediate level — 55 Node.js questions

Question 1Event Loop

Microtask vs `setTimeout` — what does this code print?

javascript

console.log('start')
setTimeout(() => console.log('timeout'), 0)
Promise.resolve().then(() => console.log('promise'))
console.log('end')

A.start end promise timeout
B.start end timeout promise
C.start timeout promise end
D.start promise timeout end

Answer: A

References

Question 2Timers

A microtask between two timers — what does this code print?

javascript

setTimeout(() => {
  console.log('timer1')
  Promise.resolve().then(() => console.log('micro'))
}, 0)
setTimeout(() => console.log('timer2'), 0)

A.timer2 timer1 micro
B.timer1 micro timer2
C.timer1 timer2 micro
D.micro timer1 timer2

Answer: B

References

Question 3Modules

The `require` cache — given these two CommonJS files, what does `node main.js` print?

// counter.js
let count = 0
module.exports = { increment: () => ++count }

// main.js
const c1 = require('./counter')
const c2 = require('./counter')
c1.increment()
c1.increment()
console.log(c2.increment())

Answer: C

References

Question 4Modules

`exports` vs `module.exports` — given these two CommonJS files, what does `node main.js` print?

// lib.js
exports.a = 1
module.exports = { b: 2 }

// main.js
const lib = require('./lib')
console.log(lib.a, lib.b)

A.undefined 2
B.1 undefined
C.1 2
D.undefined undefined

Answer: A

References

Question 5Streams & Buffer

`subarray` shares memory — what does this code print?

javascript

const buf = Buffer.from('abc')
const view = buf.subarray(0, 2)
view[0] = 120
console.log(buf.toString())

A.xb
B.120bc
C.xbc
D.abc

Answer: C

References

Question 6Process & Env

`process.env` coerces every value to a string — what does this code print?

javascript

process.env.FLAG = false
if (process.env.FLAG) {
  console.log('on')
} else {
  console.log('off')
}
console.log(typeof process.env.FLAG)

A.off boolean
B.on string
C.on boolean
D.off string

Answer: B

References

Node.js docs — process.env

Question 7Event Loop

How do `process.nextTick()` and `setImmediate()` differ in when their callbacks run?

A.The two are equivalent, differing only in syntax
B.A process.nextTick callback runs right after the current operation, before the event loop continues
C.setImmediate runs immediately in the same tick while process.nextTick waits for the next loop
D.process.nextTick runs its callback on another thread so as not to block the main one

Answer: B

References

Question 8Modules

What does this program print, and why?

javascript

// counter.js
let count = 0
module.exports = { increment: () => ++count }

// app.js
const a = require('./counter')
const b = require('./counter')
a.increment()
console.log(b.increment())

A.It prints 2 — the module is cached after the first require, so a and b are one and the same
B.An error — the same file may not be required twice in one module
C.It prints undefined — an arrow function cannot access the module-scope count
D.It prints 1 — each require loads a fresh copy of the module with its own count

Answer: A

References

Node.js — Modules: Caching

Question 9Worker Threads

How do the `cluster` and `worker_threads` modules differ in Node.js, and when do you use each?

A.cluster creates lightweight threads sharing memory with the main process, making it cheaper than worker_threads
B.worker_threads lets several threads listen on one port while cluster cannot
C.They are the same module; worker_threads is just the new name for cluster
D.cluster forks several Node PROCESSES that can share a server port

Answer: D

References

Question 10Process & Env· select all that apply

Which statements are TRUE about `spawn()`, `exec()`, and `fork()` in the `child_process` module? (select all that apply)

A.fork() is for running arbitrary shell commands with better performance than spawn()
B.exec() runs a command in a shell and buffers the entire output, delivering it once through a callback; output beyond maxBuffer errors
C.spawn() returns stdout/stderr as streams without buffering the whole output
D.exec() is best for large output because it streams the data chunk by chunk
E.fork() is a variant of spawn dedicated to running another Node.js file, with an IPC channel set up for parent–child send() messages

Answer: B, C, E

References

Node.js — Child process

Question 11Event Loop

`setImmediate` vs `setTimeout` in an I/O callback — what does this code print?

javascript

const fs = require('node:fs')
fs.readFile(__filename, () => {
  setTimeout(() => console.log('timeout'), 0)
  setImmediate(() => console.log('immediate'))
})

A.immediate timeout
B.timeout immediate
C.The order varies between runs and is not deterministic
D.(nothing is printed)

Answer: A

References

Question 12Events

EventEmitter `once` vs `on` — what does this code print?

javascript

const { EventEmitter } = require('node:events')
const emitter = new EventEmitter()
emitter.once('greet', name => console.log('once:', name))
emitter.on('greet', name => console.log('on:', name))
emitter.emit('greet', 'a')
emitter.emit('greet', 'b')

A.once: a on: a
B.once: a on: a once: b on: b
C.once: a on: a on: b
D.on: a once: a on: b

Answer: C

References

Question 13Core APIs

`structuredClone` vs `JSON.parse(JSON.stringify())` — what does this code print?

javascript

const data = { date: new Date(0), tags: new Set(['a']) }
const viaJson = JSON.parse(JSON.stringify(data))
const viaClone = structuredClone(data)
console.log(viaJson.date instanceof Date, viaClone.date instanceof Date)
console.log(viaJson.tags instanceof Set, viaClone.tags instanceof Set)

A.An error, because JSON.stringify cannot handle a Set
B.true true true true
C.false true false false
D.false true false true

Answer: D

References

Question 14Event Loop

Which operations in Node.js actually run on the libuv thread pool (4 threads by default)?

A.Filesystem (fs.*), dns.lookup(), and the CPU-heavy crypto/zlib functions (pbkdf2, scrypt, compression)
B.Every asynchronous I/O operation, HTTP requests and TCP sockets included, is handed to the thread pool
C.The thread pool runs JavaScript callbacks in parallel so several handlers execute at once
D.The thread pool only activates when using worker_threads; the fs/crypto APIs run on the main thread by default

Answer: A

References

Question 15Streams & Buffer· select all that apply

Which statements are TRUE when comparing `stream.pipeline()` with `.pipe()`? (select all that apply)

A.pipeline is significantly slower because it copies data through an intermediate buffer between each pair of streams
B.When one stream in the chain errors, pipeline destroys all the remaining streams, avoiding file descriptor leaks; .pipe() leaves the destination stream alive
C.There is a Promise version in stream/promises: await pipeline(src, transform, dest) works directly with async/await and try/catch
D..pipe() manages backpressure while pipeline does not, so large files require .pipe()
E.pipeline funnels errors from every stream in the chain into one callback/Promise; .pipe() requires manually attaching an error listener to each stream.

Answer: B, C, E

References

Question 16HTTP

What does Express add over Node's built-in `http` module?

A.Running on several threads to use all the server's CPU cores
B.HTTPS support that the core module does not provide
C.Routing, middleware and conveniences for the request and response
D.The ability to handle many concurrent connections that the core module lacks

Answer: C

References

Node.js docs — HTTP

Question 17HTTP

What happens when an Express middleware never calls `next()`?

A.The next middleware still runs but without the data already processed
B.The request hangs until it times out, unless a response was already sent
C.The request gets a 500 with a message about the failing middleware
D.The framework moves on to the next middleware automatically after a delay

Answer: B

References

Node.js docs — HTTP

Question 18HTTP

Why is `req.body` undefined when a client sends JSON to an Express server?

A.Because the request's method does not allow a body
B.Because the body exceeds the framework's default size limit
C.Because no body-parsing middleware has been registered
D.Because the client did not set the correct content-type header

Answer: C

References

Node.js docs — HTTP

Question 19Security

Who does configuring CORS on a Node server protect?

A.The server, by blocking requests from disallowed origins
B.Data in transit, by requiring the connection to be encrypted
C.Both, because the server refuses to process a request whose origin header does not match
D.Users, and the enforcement happens in the browser rather than on the server

Answer: D

References

Node.js docs — Security best practices

Question 20Streams & Buffer

What is wrong with sending a 2 GB file by reading it entirely into memory first?

A.Node does not allow a response larger than a fixed threshold
B.The connection closes because reading the file exceeds the timeout
C.The process may run out of memory, and the client waits until the whole read finishes
D.The file is corrupted because it exceeds a buffer's maximum size

Answer: C

References

Node.js docs — Stream

Question 21Security

Where is rate limiting on a Node API most effective?

A.Only in the application, since that is where the business rules live
B.At the database layer, since it is the scarcest resource
C.At the edge layer first, plus a per-account layer inside the application
D.Only at the edge, since that is the cheapest place to refuse a request

Answer: C

References

Node.js docs — Security best practices

Question 22Security

How should secrets be stored for a Node application in production?

A.An encrypted config file committed with the source for deployment convenience
B.Constants in the code but in a separate file so they are easy to find and change
C.Environment variables or a secrets manager, never committed to the repo
D.The application's database, to manage them centrally in one place

Answer: C

References

Node.js docs — Security best practices

Question 23Package Management

Which versions does `"express": "^4.18.0"` allow?

A.Exactly version 4.18.0 and nothing else
B.Any 4.x version from 4.18.0 upwards, but not 5.x
C.Only patch versions from 4.18.0 through 4.18.x
D.Every version from 4.18.0 upwards, newer major versions included

Answer: B

Any 4.x version from 4.18.0 upward — minor and patch updates are allowed, but not 5.x. The tilde is stricter, allowing only patch updates within the same minor version.

References

npm docs — package.json

Question 24Package Management

How does `npm ci` differ from `npm install`?

A.It skips packages' lifecycle scripts for safety
B.It installs only the production dependencies
C.It installs in parallel and so is much faster on a multi-core machine
D.It installs exactly per the lockfile and never modifies it

Answer: D

References

npm docs — package.json

Question 25Package Management

What do `peerDependencies` declare?

A.Packages needed only when running this package's own tests
B.That this package needs another package supplied by the host application
C.Equivalent packages that can substitute for each other at install time
D.Packages installed in parallel to shorten the install time

Answer: B

References

npm docs — package.json

Question 26Testing

Since which version does Node ship a built-in test runner, and how is it used?

A.Since Node 16, but it only supports synchronous tests
B.Node has no test runner; an external library is always required
C.Since Node 14, but it only runs files with a special extension
D.Since Node 18 (stable in Node 20), run with the test command and the node:test module

Answer: D

References

Node.js docs — Test runner

Question 27Testing

When testing a module that calls an external API, which approach gives the most stable tests?

A.Intercept at the network layer with a mock server
B.Call the real API to be sure the result matches reality
C.Replace the network-calling function with a stub returning fixed data
D.Skip testing the API call and test only the data processing

Answer: A

References

Node.js docs — Test runner

Question 28Tooling

What does Node's `--watch` flag do?

A.It restarts the process automatically when a source file changes
B.It reloads only the changed module without restarting the process
C.It monitors memory usage and warns when a threshold is passed
D.It opens a debug port for a debugger to attach to

Answer: A

References

Node.js docs — CLI

Question 29Performance

What does event loop lag measure and why does it matter?

A.The number of tasks waiting in the event loop's queue
B.The average time to finish handling one HTTP request
C.The interval between two garbage collector runs
D.The delay between a task being scheduled and actually running

Answer: D

The delay between when a task is scheduled and when it actually runs. A high value means the main thread is being held by some task — so every request is slow even though CPU usage looks normal.

References

Node.js docs — Performance measurement APIs

Question 30Modern Node

Why write `require("node:fs")` instead of `require("fs")`?

A.To state explicitly that this is a core module, which no same-named package can displace
B.To use a newer version of the module instead of an older one
C.To load the module faster by skipping the lookup step
D.To make core modules work in an ES Module context

Answer: A

References

Node.js docs — ECMAScript modules

Question 31Modern Node

Where can top-level await be used in Node?

A.In any JavaScript file from Node 14 onwards
B.Only in files with a special extension dedicated to this feature
C.Only inside a try/catch block at the top level of the file
D.Only in ES Modules, never in CommonJS

Answer: D

References

Node.js docs — ECMAScript modules

Question 32Core APIs

You need a random string as a token. Which API should you use?

A.Math.random() combined with the current timestamp
B.An incrementing counter encoded into a higher base
C.crypto.randomBytes() or crypto.randomUUID()
D.A hash of the timestamp and the process id

Answer: C

References

Node.js docs — API reference

Question 33Database

Why should a Node application use a connection pool rather than opening a new connection per request?

A.Because a pool compresses the data travelling between application and database
B.Because opening a connection costs several round trips and the database has a connection limit
C.Because a pool retries failed queries automatically after a network error
D.Because a pool guarantees every query runs in the same transaction

Answer: B

References

node-postgres — Connection pooling

Question 34Database

What must you watch for when running a transaction with a connection pool?

A.The highest isolation level must be set to avoid data conflicts
B.The transaction must run in a separate process to avoid blocking
C.Every statement must run on the same connection taken from the pool
D.The connection must be closed after the transaction rather than returned to the pool

Answer: C

References

node-postgres — Connection pooling

Question 35Operations

Why should a production Node application run behind a process manager?

A.To encrypt the traffic between the application and the connecting clients
B.To speed up JavaScript execution through cache optimisation
C.To update dependency packages automatically when new versions appear
D.To restart when the process dies and to run several processes across the cores

Answer: D

References

Node.js docs — Cluster

Question 36Operations

Why prefer structured (JSON) logging over free-text strings?

A.So logs are written faster by skipping string formatting
B.To reduce log size because JSON compresses better than plain text
C.So the system classifies each line's severity automatically
D.So it can be queried and filtered by field in the log collection system

Answer: D

References

Node.js docs — Cluster

Question 37Operations

What should a health check endpoint verify?

A.Simply returning a 200 to confirm the process is running
B.The essential dependencies, with the liveness check separated from the readiness check
C.Every service the application might call, optional ones included
D.CPU and memory usage against configured thresholds

Answer: B

References

Node.js docs — Cluster

Question 38Operations

What is the purpose of a multi-stage build in a Dockerfile for a Node application?

A.So each stage runs on a different Node version
B.To cache each layer so the build does not start from scratch each time
C.To build several components in parallel and shorten the build
D.So the final image holds only the built code and runtime dependencies, without the build tools

Answer: D

References

Node.js docs — Cluster

Question 39Modern Node

Since which version does Node ship a built-in `fetch`?

A.Node 16, but only usable in ES Modules
B.Node 14, at the same time as ES Module support
C.Node has never shipped one; an external library is always required
D.Node 18 (experimental) and stable in Node 21

Answer: D

References

Node.js docs — ECMAScript modules

Question 40Modern Node

How do you set a timeout on a `fetch` call in Node?

A.Pass an AbortSignal with a deadline into the signal option
B.Configure a global timeout through a Node environment variable
C.Pass a number of milliseconds to the call's timeout option
D.Wrap the call in a race against a promise that waits for a period

Answer: A

References

Node.js docs — ECMAScript modules

Question 41HTTP

Where should HTTP response compression (gzip or brotli) be enabled?

A.On the client side, by asking the browser to decompress
B.At the reverse proxy or CDN in front, not in the Node process
C.In the Node process, for precise control of the compression level per content type
D.In both places to be sure the response is always compressed

Answer: B

References

Node.js docs — HTTP

Question 42Security

Where and how should API input validation be done?

A.In every function that uses the data, to be sure nothing is missed
B.At the database layer, relying on the table schema's constraints
C.At the entry boundary, with a declarative schema, rejecting early
D.On the client, since that is where the user enters the data

Answer: C

References

Node.js docs — Security best practices

Question 43Performance

What problem does `JSON.stringify()` on a very large object cause?

A.It compresses the result automatically, changing the data's format
B.It runs synchronously and so blocks the main thread for the whole duration
C.It throws when the result exceeds the maximum string size
D.It skips properties nested beyond a certain depth

Answer: B

References

Node.js docs — Performance measurement APIs

Question 44Architecture

Which folder structure ages better for a mid-sized Node service?

A.Every file at the root, distinguished by a prefix in the filename
B.By technical layer, with each layer as its own package
C.By file kind: a controllers folder, a services folder, a models folder
D.By feature, each folder holding its routes, logic and data access

Answer: D

References

Node.js docs — Event loop, timers, nextTick

Question 45Performance

What should you consider first when adding a cache layer in front of a database?

A.How much memory to allocate to the cache layer
B.The serialisation format for storing values in the cache
C.Whether to use an in-process cache or a centralised one
D.How stale the data may be, and how it will be refreshed

Answer: D

How much stale data you can accept. A cache always trades freshness for speed, so decide per data type up front: a product catalog that is a few minutes old is fine, an account balance is not.

References

Node.js docs — Performance measurement APIs

Question 46Core APIs

What does `os.cpus().length` report inside a container?

A.Always 1, since Node runs JavaScript on one thread
B.The physical host's core count rather than the container's CPU limit
C.The number of cores the Node process is actually using at that moment
D.The CPU limit allocated to the container, rounded up

Answer: B

References

Node.js docs — API reference

Question 47Express

How does Express recognize a middleware as an error handler?

A.The function's or variable's name contains "error"
B.Standing immediately after the route that throws
C.The function declares exactly 4 parameters (err, req, res, next)
D.Registering it through app.error() instead of app.use()

Answer: C

References

Express docs — Error handling

Question 48Express

Running on Express 4, what happens when db.findUser rejects?

app.get('/users/:id', async (req, res) => {
  const user = await db.findUser(req.params.id) // may reject
  res.json(user)
})

A.Express retries the handler once before reporting an error
B.The 4-parameter error handler receives the error as it would a synchronous one
C.Express returns a 500 with the error details to the client
D.The promise rejection becomes unhandled rejection, and the request hangs without a response

Answer: D

References

Express docs — Catching errors

Question 49Express

Which requests does app.use('/api', router) match?

A.Also /apiv2, since it starts with the characters /api
B.Every path containing the string "api" anywhere
C.Only /api exactly — sub-paths must each be mounted separately
D./api and every sub-path of the form /api/...

Answer: D

References

Express docs — app.use()

Question 50Express

This code logs "Cannot set headers after they are sent to the client". Why?

app.get('/orders/:id', (req, res, next) => {
  res.json({ ok: true })
  next()
})

app.use((req, res) => {
  res.status(404).json({ error: 'Not found' })
})

A.A missing return before res.json makes Express send the response twice
B.next() passes the request on and the 404 middleware sends a second response
C.res.json must be the last statement in the handler
D.res.status must be called before res.json within one middleware

Answer: B

References

Express docs — The default error handler

Question 51NestJS

By what mechanism does OrdersController receive an OrdersService instance without newing it?

@Injectable()
export class OrdersService {}

@Controller('orders')
export class OrdersController {
  constructor(private readonly ordersService: OrdersService) {}
}

A.Nest's DI container creates the instance and passes it to the constructor
B.Nest scans the directory and matches a service whose filename matches the controller's
C.The @Controller decorator instantiates every class marked @Injectable()
D.TypeScript instantiates readonly parameters at compile time

Answer: A

References

NestJS docs — Dependency injection fundamentals

Question 52NestJS

Which order is correct in the NestJS request lifecycle?

A.Pipes → Guards → Middleware → Handler → Interceptors
B.Guards → Middleware → Pipes → Interceptors → Handler
C.Middleware → Pipes → Guards → Handler → Interceptors
D.Middleware → Guards → Interceptors → Pipes → Handler

Answer: D

References

NestJS docs — Request lifecycle

Question 53NestJS

A guard's canActivate returns false. What does the client receive?

A.401 Unauthorized
B.403 Forbidden
C.500 Internal Server Error because a guard must throw rather than return false
D.The request still reaches the handler but carries a rejected flag

Answer: B

References

NestJS docs — Guards

Question 54NestJS

ValidationPipe has whitelist: true. What happens to body fields not declared in the DTO?

A.Those fields are stripped from the object before the handler
B.The unknown fields move to req.rawBody for separate handling
C.It returns 400 immediately because the body contains invalid fields
D.It keeps the fields and writes a warning to the log

Answer: A

References

NestJS docs — Validation

Question 55NestJS

A NestJS handler throws new NotFoundException(). What happens next?

A.An exception filter catches it and returns a standard JSON 404
B.The process crashes because nobody catches the exception
C.The error falls through to a 4-parameter error middleware as in Express
D.A downstream interceptor turns it into a 200 with an empty body

Answer: A

References

NestJS docs — Exception filters

25 more Advanced questions for Node.js

Advanced goes deep on real-world scenarios and the technical pitfalls candidates actually run into. Included with Pro.

Upgrade to Pro

Beginner level — 20 Node.js questions

clearTimeout right after setTimeout — what does this code print?

What an async function returns — what does this code print?

Buffer.length vs String.length — what does this code print?

Node.js is described as "single-threaded" — what does that actually mean?

What is the fundamental difference between require() (CommonJS) and import (ES Modules) in Node.js?

What is the "error-first callback" convention in Node.js?

Promise.allSettled — what does this code print?

When implementing graceful shutdown for a Node.js server, which statement about the SIGTERM and SIGKILL signals is TRUE?

A Node app reads process.env.DATABASE_URL but gets undefined. Most common cause?

Why use path.join() instead of concatenating paths with /?

Why avoid fs.readFileSync() inside a request handler?

How do dependencies and devDependencies differ in package.json?

Is __dirname available in a Node ES Module file?

What encoding does buf.toString() use with no argument?

What does the NODE_ENV=production variable affect?

In Express, what determines the order in which middleware run?

An Express middleware neither calls next() nor sends a response. What happens to the request?

What is express.Router() typically used for?

In NestJS, how do controllers and providers differ?

How should you choose a Node.js version for production?

Intermediate level — 55 Node.js questions

Microtask vs setTimeout — what does this code print?

A microtask between two timers — what does this code print?

The require cache — given these two CommonJS files, what does node main.js print?

exports vs module.exports — given these two CommonJS files, what does node main.js print?

subarray shares memory — what does this code print?

process.env coerces every value to a string — what does this code print?

How do process.nextTick() and setImmediate() differ in when their callbacks run?

What does this program print, and why?

How do the cluster and worker_threads modules differ in Node.js, and when do you use each?

Which statements are TRUE about spawn(), exec(), and fork() in the child_process module? (select all that apply)

setImmediate vs setTimeout in an I/O callback — what does this code print?

EventEmitter once vs on — what does this code print?

structuredClone vs JSON.parse(JSON.stringify()) — what does this code print?

Which operations in Node.js actually run on the libuv thread pool (4 threads by default)?

Which statements are TRUE when comparing stream.pipeline() with .pipe()? (select all that apply)

What does Express add over Node's built-in http module?

What happens when an Express middleware never calls next()?

Why is req.body undefined when a client sends JSON to an Express server?

Who does configuring CORS on a Node server protect?

What is wrong with sending a 2 GB file by reading it entirely into memory first?

Where is rate limiting on a Node API most effective?

How should secrets be stored for a Node application in production?

Which versions does "express": "^4.18.0" allow?

How does npm ci differ from npm install?

What do peerDependencies declare?

Since which version does Node ship a built-in test runner, and how is it used?

When testing a module that calls an external API, which approach gives the most stable tests?

What does Node's --watch flag do?

What does event loop lag measure and why does it matter?

Why write require("node:fs") instead of require("fs")?

Where can top-level await be used in Node?

You need a random string as a token. Which API should you use?

Why should a Node application use a connection pool rather than opening a new connection per request?

What must you watch for when running a transaction with a connection pool?

Why should a production Node application run behind a process manager?

Why prefer structured (JSON) logging over free-text strings?

What should a health check endpoint verify?

What is the purpose of a multi-stage build in a Dockerfile for a Node application?

Since which version does Node ship a built-in fetch?

How do you set a timeout on a fetch call in Node?

Where should HTTP response compression (gzip or brotli) be enabled?

Where and how should API input validation be done?

What problem does JSON.stringify() on a very large object cause?

Which folder structure ages better for a mid-sized Node service?

What should you consider first when adding a cache layer in front of a database?

What does os.cpus().length report inside a container?

How does Express recognize a middleware as an error handler?

Running on Express 4, what happens when db.findUser rejects?

Which requests does app.use('/api', router) match?

This code logs "Cannot set headers after they are sent to the client". Why?

By what mechanism does OrdersController receive an OrdersService instance without newing it?

Which order is correct in the NestJS request lifecycle?

A guard's canActivate returns false. What does the client receive?

ValidationPipe has whitelist: true. What happens to body fields not declared in the DTO?

A NestJS handler throws new NotFoundException(). What happens next?

25 more Advanced questions for Node.js

Beginner level — 20 Node.js questions

clearTimeout right after setTimeout — what does this code print?

`clearTimeout` right after `setTimeout` — what does this code print?

What an `async` function returns — what does this code print?

`Buffer.length` vs `String.length` — what does this code print?

What is the fundamental difference between `require()` (CommonJS) and `import` (ES Modules) in Node.js?

`Promise.allSettled` — what does this code print?

A Node app reads `process.env.DATABASE_URL` but gets `undefined`. Most common cause?

Why use `path.join()` instead of concatenating paths with `/`?

Why avoid `fs.readFileSync()` inside a request handler?

How do `dependencies` and `devDependencies` differ in package.json?

Is `__dirname` available in a Node ES Module file?

What encoding does `buf.toString()` use with no argument?

What does the `NODE_ENV=production` variable affect?

Microtask vs `setTimeout` — what does this code print?

The `require` cache — given these two CommonJS files, what does `node main.js` print?

`exports` vs `module.exports` — given these two CommonJS files, what does `node main.js` print?

`subarray` shares memory — what does this code print?

`process.env` coerces every value to a string — what does this code print?

How do `process.nextTick()` and `setImmediate()` differ in when their callbacks run?

How do the `cluster` and `worker_threads` modules differ in Node.js, and when do you use each?

Which statements are TRUE about `spawn()`, `exec()`, and `fork()` in the `child_process` module? (select all that apply)

`setImmediate` vs `setTimeout` in an I/O callback — what does this code print?

EventEmitter `once` vs `on` — what does this code print?

`structuredClone` vs `JSON.parse(JSON.stringify())` — what does this code print?

Which statements are TRUE when comparing `stream.pipeline()` with `.pipe()`? (select all that apply)

What does Express add over Node's built-in `http` module?

What happens when an Express middleware never calls `next()`?

Why is `req.body` undefined when a client sends JSON to an Express server?

Which versions does `"express": "^4.18.0"` allow?

How does `npm ci` differ from `npm install`?

What do `peerDependencies` declare?

What does Node's `--watch` flag do?

Why write `require("node:fs")` instead of `require("fs")`?

Since which version does Node ship a built-in `fetch`?

How do you set a timeout on a `fetch` call in Node?

What problem does `JSON.stringify()` on a very large object cause?

What does `os.cpus().length` report inside a container?

`clearTimeout` right after `setTimeout` — what does this code print?

What an `async` function returns — what does this code print?

`Buffer.length` vs `String.length` — what does this code print?

What is the fundamental difference between `require()` (CommonJS) and `import` (ES Modules) in Node.js?

`Promise.allSettled` — what does this code print?

A Node app reads `process.env.DATABASE_URL` but gets `undefined`. Most common cause?

Why use `path.join()` instead of concatenating paths with `/`?

Why avoid `fs.readFileSync()` inside a request handler?

How do `dependencies` and `devDependencies` differ in package.json?

Is `__dirname` available in a Node ES Module file?

What encoding does `buf.toString()` use with no argument?

What does the `NODE_ENV=production` variable affect?

Microtask vs `setTimeout` — what does this code print?

The `require` cache — given these two CommonJS files, what does `node main.js` print?

`exports` vs `module.exports` — given these two CommonJS files, what does `node main.js` print?

`subarray` shares memory — what does this code print?

`process.env` coerces every value to a string — what does this code print?

How do `process.nextTick()` and `setImmediate()` differ in when their callbacks run?

How do the `cluster` and `worker_threads` modules differ in Node.js, and when do you use each?

Which statements are TRUE about `spawn()`, `exec()`, and `fork()` in the `child_process` module? (select all that apply)

`setImmediate` vs `setTimeout` in an I/O callback — what does this code print?

EventEmitter `once` vs `on` — what does this code print?

`structuredClone` vs `JSON.parse(JSON.stringify())` — what does this code print?

Which statements are TRUE when comparing `stream.pipeline()` with `.pipe()`? (select all that apply)

What does Express add over Node's built-in `http` module?

What happens when an Express middleware never calls `next()`?

Why is `req.body` undefined when a client sends JSON to an Express server?

Which versions does `"express": "^4.18.0"` allow?

How does `npm ci` differ from `npm install`?

What do `peerDependencies` declare?

What does Node's `--watch` flag do?

Why write `require("node:fs")` instead of `require("fs")`?

Since which version does Node ship a built-in `fetch`?

How do you set a timeout on a `fetch` call in Node?

What problem does `JSON.stringify()` on a very large object cause?