Node.js Fundamentals Interview Quiz

Q: How many questions are in the Node.js quiz?

There are 30 questions total: 10 Beginner, 10 Intermediate, and 10 Advanced, randomized on each playthrough.

Q: Which Node.js versions are tested?

The questions align with modern LTS releases (Node.js 18, 20, and 22), covering native ESM and current core APIs.

Q: Does the quiz work on mobile?

Yes, the interface is fully responsive across mobile phones, tablets, and desktop browsers.

Question 1

Node.js is described as "single-threaded". What does this primarily mean in the context of JavaScript execution?

Accepted Answer

JavaScript code runs on a single call stack in one thread

Answer

It can only handle one HTTP request at a time

Answer

It uses only one CPU core for all operations

Answer

It cannot run multiple Node.js processes on the same machine

Question 2

What does `require('fs')` do in a Node.js module?

Accepted Answer

Loads the built-in file system module and returns its cached exports

Answer

Fetches the 'fs' package from the public npm repository at runtime

Answer

Allocates an isolated file system thread instance for this module

Answer

Registers a global file system event subscriber on the process loop

Question 3

Which field in `package.json` specifies the entry point file that Node.js loads when your package is `require()`-d?

Accepted Answer

main

Answer

start

Answer

index

Answer

entry

Question 4

What is the key difference between `fs.readFileSync()` and `fs.readFile()` in Node.js?

Accepted Answer

`readFileSync` blocks the event loop; `readFile` is non-blocking and async

Answer

`readFileSync` reads bigger files; `readFile` caps sizes to 1 megabyte

Answer

`readFile` has been deprecated; `readFileSync` is the recommended standard

Answer

Both methods are identical; the 'Sync' suffix is solely syntactic sugar

Question 5

In Node.js, what is a callback?

Accepted Answer

A function passed to another function, invoked when async work completes

Answer

A built-in system error class for capturing asynchronous stream faults

Answer

A synchronous wrapper that mimics Promise resolution in legacy modules

Answer

A specialized lifecycle hook available on the EventEmitter base class

Question 6

How do you read an environment variable named `PORT` in a Node.js process?

Accepted Answer

`process.env.PORT`

Answer

`env.get('PORT')`

Answer

`os.env('PORT')`

Answer

`global.PORT`

Question 7

Which built-in Node.js module would you use to join two path segments in a cross-platform safe way?

Accepted Answer

`path`

Answer

`fs`

Answer

`url`

Answer

`os`

Question 8

What does `npm run build` execute?

Accepted Answer

Runs the `build` script defined under the `scripts` key in `package.json`

Answer

Downloads and installs all packages listed in `dependencies`

Answer

Compiles all `.ts` files to `.js` using Node's built-in compiler

Answer

Creates a production bundle and uploads it to npm

Question 9

In a Node.js stack trace, what does the line `at Object.<anonymous> (app.js:42:15)` tell you?

Accepted Answer

The error originated at line 42, column 15 of `app.js`

Answer

An anonymous object was exported from `app.js`

Answer

The file `app.js` has 42 exports

Answer

Process memory usage at the time of the error

Question 10

Which of the following is available in a browser's JavaScript runtime but NOT in Node.js by default?

Accepted Answer

`window`

Answer

`setTimeout`

Answer

`Promise`

Answer

`Array.prototype.map`

Question 11

What is the correct execution order for the following code?
```js
setTimeout(() => console.log('A'), 0);
setImmediate(() => console.log('B'));
process.nextTick(() => console.log('C'));
console.log('D');
```

Accepted Answer

D → C → B → A

Answer

D → A → B → C

Answer

D → C → A → B

Answer

A → B → C → D

Question 12

In what phase of the Node.js event loop does `setImmediate()` fire?

Accepted Answer

Check phase

Answer

Timers phase

Answer

Poll phase

Answer

Close callbacks phase

Question 13

Which of the following has the highest execution priority in Node.js's async scheduling?

Accepted Answer

`process.nextTick(fn)`

Answer

`setTimeout(fn, 0)`

Answer

`setImmediate(fn)`

Answer

Resolved `Promise` `.then()` callbacks

Question 14

What type of Node.js stream would you use to both read from and write to, AND transform the data in transit (e.g., a gzip compressor)?

Accepted Answer

Transform stream

Answer

Readable stream

Answer

Writable stream

Answer

Duplex stream

Question 15

What is the primary purpose of the Node.js `cluster` module?

Accepted Answer

To fork processes sharing a port, utilizing multiple CPU cores

Answer

To mirror npm packages across distributed cluster compute machines

Answer

To spawn isolated child processes that run scripts without shared state

Answer

To spawn dedicated thread pools for compute-heavy synchronous tasks

Question 16

How does `worker_threads` differ from `child_process` in Node.js?

Accepted Answer

`worker_threads` share memory buffers; `child_process` spawns OS processes

Answer

`child_process` processes CPU work faster by adopting native system threads

Answer

`worker_threads` cannot exchange messages with the main execution thread

Answer

Both modules are interchangeable and share identical underlying engines

Question 17

In V8's heap layout, what is the "New Space" (Young Generation) used for?

Accepted Answer

Short-lived objects that are expected to be collected quickly

Answer

Storing compiled machine code for JIT-compiled functions

Answer

Large objects over 1 MB that cannot fit in regular pages

Answer

The call stack and local variable frames

Question 18

When a Node.js module is `require()`-d a second time, what happens?

Accepted Answer

The cached `exports` reference from the initial load returns immediately

Answer

The module source file is parsed from storage and re-executed in memory

Answer

An initialization error is thrown to stop duplicate module allocations

Answer

A separate isolated execution context is initialized for the module

Question 19

Which `EventEmitter` method registers a listener that fires only once and then automatically removes itself?

Accepted Answer

`emitter.once(event, listener)`

Answer

`emitter.on(event, listener)`

Answer

`emitter.addOnceListener(event, listener)`

Answer

`emitter.emit(event, { once: true })`

Question 20

What is libuv's role in Node.js?

Accepted Answer

The C library providing async I/O event loops, thread pools, and OS layers

Answer

The JavaScript engine compiling source syntax into native machine code

Answer

The package management client orchestrating dependency resolution trees

Answer

The protocol module implementing HTTP/2 framing and multiplexed sockets

Question 21

Which garbage collection algorithm does V8 use for the Young Generation (New Space)?

Accepted Answer

Scavenge (semi-space copy)

Answer

Generational Mark-Sweep

Answer

Concurrent Mark-Compact

Answer

Reference counting cycle

Question 22

Why can a full Mark-Compact GC cycle cause observable latency spikes in a Node.js server?

Accepted Answer

It runs stop-the-world pauses while compacting the Old Space, blocking the event loop

Answer

It temporarily doubles memory usage by copying the entire heap

Answer

It recompiles all JIT-optimized functions to free code cache memory

Answer

It flushes the libuv thread pool and restarts all pending I/O operations

Question 23

You run `node --prof app.js` and then `node --prof-process isolate-*.log`. What kind of output does this produce?

Accepted Answer

A human-readable statistical CPU profile showing hot functions and their call percentages

Answer

A heap snapshot in JSON format compatible with Chrome DevTools

Answer

A timeline of all GC pauses with their durations in milliseconds

Answer

A network waterfall diagram of all HTTP requests made during the run

Question 24

Which of the following patterns is the most common cause of memory leaks in long-running Node.js servers?

Accepted Answer

Accumulating listeners on an EventEmitter without removing old handlers

Answer

Declaring immutable variables with `const` instead of `let` in root scope

Answer

Invoking `JSON.parse` continuously on moderately sized payload objects

Answer

Adopting `async/await` syntax instead of traditional Node error callbacks

Question 25

What does the Node.js flag `--max-old-space-size=4096` control?

Accepted Answer

The upper limit of V8's Old Space heap in megabytes before OOM is thrown

Answer

The maximum number of files that can be open simultaneously

Answer

The size of libuv's thread pool in megabytes

Answer

The maximum allowed size of a single JSON payload parsed with `JSON.parse`

Question 26

A synchronous CPU-bound loop running for 2 seconds is accidentally placed in an HTTP request handler. What is the most accurate description of the impact?

Accepted Answer

The poll phase is blocked, stalling all concurrent requests and timers

Answer

Only the caller request halts; remaining incoming requests process fine

Answer

Libuv offloads the loop to background worker threads to protect sockets

Answer

The primary cluster process detects the loop and restarts the instance

Question 27

What is back-pressure in Node.js streams, and what role does `highWaterMark` play?

Accepted Answer

Back-pressure signals full buffers; `highWaterMark` sets write threshold

Answer

Back-pressure is an HTTP rate limiter; `highWaterMark` sets RPS ceilings

Answer

Back-pressure signals GC delays; `highWaterMark` triggers heap compacts

Answer

Back-pressure is unused in streams; it is only relevant to TCP socket tiers

Question 28

What is the primary advantage of N-API (now Node-API) over previous native addon interfaces?

Accepted Answer

It provides ABI stability so addons do not require rebuilds per Node release

Answer

It permits writing high-performance addons in Python instead of C++ code

Answer

It exposes direct internal hooks into the V8 engine heap memory allocations

Answer

It automatically multi-threads addon functions across all host machine cores

Question 29

How do V8 "hidden classes" (also called "shapes" or "maps") improve JavaScript object performance?

Accepted Answer

They let V8 generate optimized code by tracking object property layouts

Answer

They compress object hash keys in memory using shared byte dictionaries

Answer

They hide private class members from the garbage collector mark phase

Answer

They pre-allocate static fixed memory heaps for each constructor call

Question 30

When using PM2 to achieve zero-downtime restarts (`pm2 reload`), what mechanism does PM2 use?

Accepted Answer

It spawns a worker, waits for readiness, shifts traffic, then kills the old

Answer

It pauses load balancers, reboots all workers at once, then resumes traffic

Answer

It dynamically patches byte code in memory without spawning child processes

Answer

It relies on kernel memory page swaps to replace running application code

Node.js Fundamentals Interview Quiz

What the Node.js Fundamentals interview quiz covers

Difficulty levels

Question topics covered

How to use the Node.js quiz

Frequently asked questions about the Node.js quiz

TypeScript

System Architecture

Database Design

Node.js Fundamentals Interview Quiz

What the Node.js Fundamentals interview quiz covers

Difficulty levels

Question topics covered

How to use the Node.js quiz

Frequently asked questions about the Node.js quiz

Related Interview Drills

TypeScript

System Architecture

Database Design