Middle Node.js Interview Questions (50 MCQs)

Question 1

In CommonJS, what does `Promise.resolve().then(() => { process.nextTick(() => console.log('tick')); Promise.resolve().then(() => console.log('p2')); console.log('p1'); });` print?

Accepted Answer

`p1 p2 tick`

Answer

`p1 tick p2`

Answer

`tick p1 p2`

Answer

`p2 p1 tick`

Question 2

What problem does a function that recursively reschedules itself with `process.nextTick` cause?

Accepted Answer

I/O and timers starve, because the nextTick queue never empties

Answer

An immediate stack overflow, since nextTick is synchronous

Answer

None; nextTick yields to I/O after every phase

Answer

Node auto-converts it to setImmediate after 1000 iterations

Question 3

What does the event loop do in the poll phase when its queue is empty?

Accepted Answer

Moves to check if setImmediate is pending; otherwise waits for I/O up to the next timer

Answer

Always jumps straight back to timers and busy-waits

Answer

Exits the process, since nothing is left to do

Answer

Runs close callbacks and then halts permanently

Question 4

In Node 11+, what does `setTimeout(() => { console.log('t1'); Promise.resolve().then(() => console.log('p')); }); setTimeout(() => console.log('t2'));` print?

Accepted Answer

`t1 p t2`

Answer

`t1 t2 p`

Answer

`p t1 t2`

Answer

`t2 t1 p`

Question 5

In Node 15+, what does an unhandled Promise rejection do by default?

Accepted Answer

It's raised as an uncaught exception and the process exits non-zero

Answer

Only a warning is printed and the process continues

Answer

It's silently ignored

Answer

The Promise is automatically retried

Question 6

What's the right approach inside a `process.on('uncaughtException')` handler?

Accepted Answer

Log the error, clean up if possible, then exit the process

Answer

Log the error and let the server keep running normally

Answer

Automatically retry the requests that failed

Answer

Ignore it, since Node restores state on its own

Question 7

When a package defines `exports`, what happens to `require('pkg/lib/internal.js')` if that path isn't listed?

Accepted Answer

It throws `ERR_PACKAGE_PATH_NOT_EXPORTED`

Answer

It loads the file normally, since it exists

Answer

It returns the `main` file instead

Answer

It prints a deprecation warning and loads it

Question 8

What are the `import` and `require` conditions in `exports` for?

Accepted Answer

Serving different entry points to ESM and CommonJS consumers

Answer

Choosing which dependencies get downloaded at install time

Answer

Restricting the package to specific Node versions

Answer

Pointing to TypeScript files for type checking

Question 9

Which feature is available in ES Modules but not in CommonJS?

Accepted Answer

Top-level `await` at module scope

Answer

Using `async function`

Answer

Dynamic import via `import()`

Answer

Reading `process.env` variables

Question 10

If `a.js` requires `b.js` and `b.js` requires `a.js`, what does `b.js` receive from `a`?

Accepted Answer

A partially populated `module.exports` of `a`

Answer

A circular dependency error that stops the process

Answer

A brand-new instance of `a` executed from scratch

Answer

The complete `a`, because Node reorders loading automatically

Question 11

Where does Node look for `require('lodash')` from `/app/src/utils/x.js`?

Accepted Answer

`node_modules` in the current folder, then each parent up to the root

Answer

Only `/app/node_modules`, where `package.json` lives

Answer

Only the global npm folder

Answer

Directly from the npm registry at runtime

Question 12

What does `delete require.cache[require.resolve('./cfg')]` do?

Accepted Answer

The next `require` reloads and re-executes the module from disk

Answer

It removes the module from memory and from all existing references

Answer

It deletes `cfg.js` from disk

Answer

It has exactly the same effect on ESM imports

Question 13

Why would a React plugin list `react` in `peerDependencies`?

Accepted Answer

So it uses the host project's React instead of installing a duplicate

Answer

So React is only installed in development

Answer

So React always upgrades to the latest version

Answer

Because `dependencies` can't hold large packages

Question 14

When `writable.write(chunk)` returns `false`, what should the producer do?

Accepted Answer

Stop writing and wait for the `'drain'` event

Answer

Rewrite the same chunk immediately, since it was dropped

Answer

Close the stream, because an error occurred

Answer

Keep writing; the return value is informational only

Question 15

Why is `stream.pipeline` preferred over `a.pipe(b).pipe(c)`?

Accepted Answer

It forwards errors from any stage and destroys all streams on failure

Answer

It processes data in parallel across multiple cores

Answer

It disables backpressure for better throughput

Answer

It's just shorter syntax with identical behavior

Question 16

To convert a CSV file to JSON line by line while streaming, which stream type fits?

Accepted Answer

Transform

Answer

Readable

Answer

Writable

Answer

PassThrough

Question 17

Why is `net.Socket` a Duplex rather than a Transform?

Accepted Answer

Its read and write sides are independent; output isn't derived from input

Answer

Because a socket is read-only

Answer

Because Transform can't handle binary data

Answer

Because Duplex is faster and Node always prefers it

Question 18

What does `objectMode: true` change on a stream?

Accepted Answer

It can carry any JS value and `highWaterMark` counts objects

Answer

Data is automatically serialized with `JSON.stringify`

Answer

The stream only accepts `Buffer` objects

Answer

Backpressure is disabled for that stream

Question 19

What's the benefit of `for await (const chunk of readable)` for consuming a Readable?

Accepted Answer

It respects backpressure and surfaces stream errors as throws in `try/catch`

Answer

It preloads every chunk into memory for speed

Answer

It processes chunks in parallel

Answer

It only works on objectMode streams

Question 20

What exactly is `highWaterMark` on a stream?

Accepted Answer

The internal buffer threshold at which backpressure kicks in

Answer

The absolute maximum data the stream can ever transfer

Answer

The exact size every chunk must have

Answer

The maximum wait for data in milliseconds

Question 21

How does Express recognize a middleware as an error handler?

Accepted Answer

The function declares exactly four parameters: `(err, req, res, next)`

Answer

It's registered with `app.error()` instead of `app.use()`

Answer

The function must be named `errorHandler`

Answer

It must be registered before all routes

Question 22

In Express 4, what happens when an `async` route handler throws?

Accepted Answer

The Promise rejects unhandled; you must call `next(err)` yourself

Answer

Express automatically forwards it to the error middleware

Answer

Express replies `500` and logs the error

Answer

The request ends with an empty `200` response

Question 23

What happens if `app.use(authMiddleware)` is placed after `app.get('/admin', ...)`?

Accepted Answer

`/admin` responds without auth, because the middleware runs after it

Answer

Express automatically reorders middleware before routes

Answer

Express throws at startup

Answer

The middleware only runs for POST requests

Question 24

What's the benefit of defining a response JSON Schema in Fastify?

Accepted Answer

Faster serialization and no leaking of unlisted fields

Answer

Fastify can't send JSON without it

Answer

It caches responses in Redis automatically

Answer

It enables TypeScript at runtime

Question 25

In Node 20.6+, how do you load a `.env` file without the `dotenv` package?

Accepted Answer

`node --env-file=.env app.js`

Answer

Node always loads `.env` from the project root automatically

Answer

`node --config=.env app.js`

Answer

`import '.env'` at the top of the file

Question 26

When is the best time to validate required environment variables?

Accepted Answer

At startup, failing fast if anything is missing or invalid

Answer

The first time each variable is used inside a request

Answer

Never; falling back to empty strings is enough

Answer

In a nightly cron job that checks the config

Question 27

To resize images with a pure-JavaScript library inside an API, which approach fits best?

Accepted Answer

Run the work on `worker_threads` so the main thread stays free

Answer

Wrap the code in an `async function` to make it non-blocking

Answer

Run the work inside `setImmediate`

Answer

Increase `UV_THREADPOOL_SIZE`

Question 28

For a command producing gigabytes of output, why is `spawn` better than `exec`?

Accepted Answer

`spawn` streams output, while `exec` buffers it in memory up to `maxBuffer`

Answer

`spawn` runs the command on a worker thread

Answer

`exec` only works on Windows

Answer

`spawn` compresses the output automatically

Question 29

What problem does the `cluster` module solve?

Accepted Answer

Running several processes on one port to use all CPU cores

Answer

Sharing memory between threads with SharedArrayBuffer

Answer

Connecting multiple Node servers to one shared database

Answer

Running several event loops inside a single process

Question 30

What is the default size of libuv's thread pool (`UV_THREADPOOL_SIZE`)?

Accepted Answer

`4`

Answer

Equal to the number of CPU cores

Answer

`1`

Answer

`128`

Question 31

Which operation does NOT use the libuv thread pool?

Accepted Answer

Reading and writing a TCP network socket

Answer

`fs.readFile`

Answer

`crypto.pbkdf2`

Answer

`zlib.gzip`

Question 32

What does an endpoint running `JSON.parse` on a 100 MB payload do to the server?

Accepted Answer

It blocks the event loop and raises latency for every request

Answer

Only that request slows, since parsing is asynchronous

Answer

V8 automatically offloads parsing to the thread pool

Answer

No effect, because V8 JIT-compiles JSON

Question 33

In a graceful shutdown after `SIGTERM`, what's the usual first step?

Accepted Answer

`server.close()` to stop new connections while in-flight requests finish

Answer

An immediate `process.exit(0)` to stop quickly

Answer

Closing the database connection before anything else

Answer

Ignoring the signal so the orchestrator retries

Question 34

Which signal cannot be caught with `process.on(...)`?

Accepted Answer

`SIGKILL`

Answer

`SIGTERM`

Answer

`SIGINT`

Answer

`SIGHUP`

Question 35

What's the simplest way to give `fetch` a 5-second timeout in Node?

Accepted Answer

`fetch(url, { signal: AbortSignal.timeout(5000) })`

Answer

`fetch(url, { timeout: 5000 })`

Answer

`setTimeout(() => fetch.cancel(), 5000)`

Answer

`Promise.race` with a timer, which also cancels the request

Question 36

What's the standard way to make a custom async function cancellable?

Accepted Answer

Accept a `signal` and check `signal.aborted` or listen for `'abort'`

Answer

Return a Promise and call `promise.cancel()`

Answer

Throw into the function from outside using `process.kill`

Answer

Set a global variable named `cancelled`

Question 37

Why use a structured logger like pino instead of `console.log` in production?

Accepted Answer

Leveled JSON output with context that's searchable and cheap

Answer

Because `console.log` is disabled in production

Answer

Because pino encrypts logs automatically

Answer

Because `console.log` only accepts strings

Question 38

Which statement about the built-in `node:test` runner is true?

Accepted Answer

It runs via `node --test` and offers mocks, subtests and coverage with no deps

Answer

It only works on TypeScript files

Answer

It must be installed with `npm install node-test`

Answer

It only provides assertions and can't run tests

Question 39

In Jest, how do you test a service without really calling the `./db` module?

Accepted Answer

`jest.mock('./db')` and set return values with `mockResolvedValue`

Answer

Temporarily delete `db.js` while tests run

Answer

Set `NODE_ENV=test`, which makes Jest disable the database

Answer

Wrap calls in `try/catch` so connection errors are ignored

Question 40

For downloading 10,000 URLs, why is `Promise.all(urls.map(fetch))` a bad idea?

Accepted Answer

All requests start at once, exhausting sockets, memory or the server's rate limit

Answer

`Promise.all` accepts at most 100 Promises

Answer

The requests run one after another, which is very slow

Answer

`fetch` inside `map` always runs synchronously

Question 41

What does `await once(server, 'listening')` from `node:events` do?

Accepted Answer

Waits for the first `'listening'` event, rejecting if `'error'` fires first

Answer

Registers a permanent listener resolving on every event

Answer

Emits the `'listening'` event once

Answer

Opens the server for a single connection only

Question 42

What does a `MaxListenersExceededWarning` usually indicate?

Accepted Answer

A likely leak; often a listener added per request and never removed

Answer

The server exceeded its concurrent connection limit

Answer

EventEmitter doesn't support async events

Answer

Listeners are executing too slowly

Question 43

What's the difference between `Buffer.alloc(n)` and `Buffer.allocUnsafe(n)`?

Accepted Answer

`allocUnsafe` skips zero-filling and may contain old, sensitive data

Answer

`allocUnsafe` allocates outside the process, on disk

Answer

`alloc` is for strings and `allocUnsafe` for binary data

Answer

`allocUnsafe` was removed from Node and throws

Question 44

For a service constantly calling another HTTP API, what does keep-alive give you?

Accepted Answer

Reusing TCP/TLS connections, avoiding a handshake per request

Answer

Sending every request together in a single message

Answer

Automatic in-memory caching of responses

Answer

Guaranteeing the remote server never times out

Question 45

What does `npm audit` do?

Accepted Answer

Checks the dependency tree against a database of known vulnerabilities

Answer

Statically analyzes your own code for security bugs

Answer

Upgrades every package to its latest major version

Answer

Removes unused packages from `package.json`

Question 46

Why doesn't `process.on('exit', async () => { await db.close(); })` work?

Accepted Answer

Only synchronous code runs in `'exit'`; the event loop won't run anything after

Answer

Because `'exit'` is only emitted on Windows

Answer

Because an `'exit'` handler can't be an arrow function

Answer

Because `'exit'` fires before the program starts

Question 47

What is `stream.finished(s, cb)` for?

Accepted Answer

Getting one callback when a stream ends, errors or closes prematurely

Answer

Forcing a stream to end immediately and discarding its buffer

Answer

Synchronously checking whether a stream has finished

Answer

Turning a Readable into a Writable after reading ends

Question 48

In which event loop phase does a `socket.on('close', ...)` callback run after `socket.destroy()`?

Accepted Answer

close callbacks

Answer

timers

Answer

check

Answer

pending callbacks

Question 49

To give every log line of a request its `requestId` without passing it manually, what do you use?

Accepted Answer

`AsyncLocalStorage`, which carries context across the async chain

Answer

A global variable set at the start of every request

Answer

Storing `requestId` in `process.env` per request

Answer

A `WeakMap` keyed by the current `Promise`

Question 50

A transitive dependency is vulnerable and its parent hasn't updated it; how do you force its version in npm?

Accepted Answer

With the `overrides` field in `package.json`

Answer

By manually editing files inside `node_modules`

Answer

By adding it to `peerDependencies`

Answer

With the `engines` field in `package.json`