Question 1

What is Node.js and how does its non-blocking I/O model work?

Accepted Answer

Node.js is an open-source, cross-platform runtime environment built on Google Chrome's V8 engine that executes JavaScript on the server. Node.js uses a single-threaded event loop and a non-blocking I/O model to handle concurrency. When an I/O request (like reading a file or making a network request) is initiated, Node delegates the operation to the operating system or system kernel. Once completed, a callback is added to the event loop queue to be executed, allowing the single main thread to continue processing other incoming requests without waiting.

Question 2

Explain the Event Loop in Node.js and its core phases.

Accepted Answer

The Event Loop is what allows Node.js to perform non-blocking I/O operations despite being single-threaded. It executes in six distinct phases sequentially:
1. Timers: Executes callbacks scheduled by `setTimeout()` and `setInterval()`.
2. Pending Callbacks: Executes I/O callbacks deferred to the next loop iteration.
3. Idle, Prepare: Used only internally.
4. Poll: Retrieves new I/O events, executing I/O related callbacks.
5. Check: Executes `setImmediate()` callbacks.
6. Close Callbacks: Executes close event callbacks (like `socket.on('close')`).

Question 3

What is the difference between setImmediate() and setTimeout(fn, 0)?

Accepted Answer

- `setImmediate()` is designed to execute a script once the current Event Loop poll phase completes.
- `setTimeout(fn, 0)` schedules a script to run after a minimum threshold of 0 milliseconds has elapsed. If called from the main thread, the execution order depends on system performance, but if called inside an I/O cycle, `setImmediate()` is guaranteed to execute first.

Question 4

What is process.nextTick() in Node.js?

Accepted Answer

`process.nextTick()` is not technically part of the Event Loop. Instead, it instructs the runtime to process the callback immediately after the current operation completes, before the Event Loop continues to the next phase. Overusing `process.nextTick()` can starve the event loop by preventing it from reaching the poll phase.

Question 5

What are Streams in Node.js and what are the four main types?

Accepted Answer

Streams are collections of data that might not be available all at once or fit in memory, handled block-by-block. The four main types are:
1. Readable: Streams from which data can be read (e.g. `fs.createReadStream()`).
2. Writable: Streams to which data can be written (e.g. `fs.createWriteStream()`).
3. Duplex: Streams that are both Readable and Writable (e.g. TCP sockets).
4. Transform: Duplex streams that can modify data as it is written and read (e.g. zlib compression).

Question 6

Explain backpressure in Node.js Streams.

Accepted Answer

Backpressure occurs when data is read from a readable stream faster than the writable stream can process it. The memory buffer fills up, increasing memory usage. To handle this, the readable stream must pause reading when the writable stream's buffer exceeds its `highWaterMark`, and resume only after the writable stream fires the `drain` event.

Question 7

What is the difference between package.json and package-lock.json?

Accepted Answer

`package.json` contains metadata, scripts, and semantic version ranges for dependencies. `package-lock.json` records the exact version of every package installed, along with a dependency tree and integrity hashes, ensuring consistent builds across machines.

Question 8

How do you handle environment variables in a Node.js application?

Accepted Answer

Environment variables are accessed via `process.env`. In development, they are loaded from a `.env` file using modules like `dotenv`. In production, they are configured on the hosting server, ensuring secrets are not committed to source code.

Question 9

What is the purpose of the Buffer class in Node.js?

Accepted Answer

The `Buffer` class represents a fixed-size chunk of memory allocated outside the V8 heap, used to handle raw binary data streams (like TCP streams, file system operations, and images) that JavaScript originally could not process natively.

Question 10

What is the difference between path.join() and path.resolve()?

Accepted Answer

- `path.join()` joins all given path segments together using the platform-specific separator and normalizes the resulting path.
- `path.resolve()` resolves the segments into an absolute path, treating the working directory (`process.cwd()`) as the base.

Question 11

Explain the difference between spawn() and fork() in child_process.

Accepted Answer

- `spawn()` launches a new process in a shell, streaming command data via stdio, ideal for long-running commands.
- `fork()` is a special case of `spawn()` that runs a new Node instance, establishing an IPC channel for message passing.

Question 12

How do you handle exceptions in Node.js to prevent crashes?

Accepted Answer

Wrap synchronous code in `try-catch` blocks and use `.catch()` on promises. Handle unhandled exceptions globally using `process.on('uncaughtException', ...)` and `process.on('unhandledRejection', ...)` to log errors and exit cleanly.

Question 13

What is the EventEmitter class and how does it work?

Accepted Answer

The `EventEmitter` class facilitates communication between objects in Node.js. It allows objects to emit named events that trigger registered listener callbacks: `emitter.emit('event')` and `emitter.on('event', callback)`.

Question 14

Explain CommonJS module loading rules in Node.js.

Accepted Answer

CommonJS uses `require()` to load modules synchronously. It resolves paths, executes the target file once, caches the exported `module.exports` object, and returns it, making subsequent requires fast.

Question 15

What is REPL in Node.js?

Accepted Answer

REPL stands for Read-Eval-Print Loop. It is the interactive computer environment (terminal) that takes user inputs, evaluates them, prints the results, and loops back, allowing quick JavaScript experimentation.

Question 16

Explain the difference between readFileSync and readFile.

Accepted Answer

`readFileSync` blocks the main execution thread until the file is fully read, which is fine for startup scripts but bad for servers. `readFile` is asynchronous, delegating the read task and returning execution via callback.

Question 17

What is the role of the global object in Node.js?

Accepted Answer

The `global` object is the top-level scope container in Node.js, equivalent to `window` in browsers. Variables declared globally without `var`/`let` are attached to it, though this is discouraged in clean code.

Question 18

Explain how Node.js resolves modules in dependencies.

Accepted Answer

Node checks core modules first. If not found, it checks `node_modules` in the current folder, then bubbles up parent directories looking for the package name, resolving files via `main` properties in `package.json`.

Question 19

What is the purpose of npm prune?

Accepted Answer

`npm prune` scans your local `node_modules` folder and deletes any packages that are not listed in your `package.json` dependencies list, keeping development workspaces clean.

Question 20

What is the difference between dependency and devDependency?

Accepted Answer

`dependencies` are packages required for the application to run in production. `devDependencies` are packages only needed during development and testing (like Jest, TypeScript compilers, or ESLint).

Question 21

How do you detect and profile memory leaks in Node.js servers?

Accepted Answer

Memory leaks in Node.js typically occur when global variables, event listeners, or cache objects retain references to dead objects. Start Node with inspect flags: `node --inspect index.js`. Connect Chrome DevTools to the Node process, take Heap Snapshots under the Memory tab, and compare snapshots before and after sending mock traffic using load testers (like autocannon) to identify growing constructor instance counts.

Question 22

What are Worker Threads in Node.js and when should you use them?

Accepted Answer

Worker Threads (`worker_threads` module) allow you to run CPU-intensive tasks (like image processing, cryptography, or heavy mathematical calculations) in background threads, sharing memory using `SharedArrayBuffer`. Use them when tasks would block the main single thread, as blocking the main thread degrades response times for all incoming HTTP requests.

Question 23

Explain the cluster module in Node.js and how it implements scaling.

Accepted Answer

The `cluster` module lets you spawn multiple instances of your Node.js application, sharing the same server port. It spawns worker processes using `child_process.fork`. The master process acts as a load balancer, distributing incoming connections to workers using a Round-Robin algorithm, maximizing CPU usage on multi-core servers.

Question 24

How do you write unit tests for Node.js API endpoints using Supertest?

Accepted Answer

Supertest wraps your Express or NestJS app instance, allowing you to trigger mock HTTP requests without starting a live network server. You assert responses using promise chains:
```javascript
const request = require('supertest');
const app = require('./app');

test('GET /api/users', async () => {
  const res = await request(app)
    .get('/api/users')
    .expect('Content-Type', /json/)
    .expect(200);
  expect(res.body.users).toBeDefined();
});
```

Question 25

Explain how to secure Node.js APIs against Brute Force attacks.

Accepted Answer

Implement rate-limiting middleware (like `express-rate-limit` or Redis-based limiters). Track client IP addresses and limit the number of requests they can make within a time window (e.g. 100 requests every 15 minutes), returning a 429 status code if exceeded.

Question 26

Explain the difference between event-driven architecture and thread pool architecture.

Accepted Answer

Event-driven architecture uses a single thread to handle loop triggers and delegate tasks, maintaining low memory footprints. Thread pool architecture (like Apache) spawns dedicated OS threads per connection, which can run out of memory under high concurrent loads.

Question 27

How does the libuv thread pool function under the hood?

Accepted Answer

libuv is the C library that handles Node's async tasks. While network I/O is handled natively by the OS kernel, file system operations, cryptography (`crypto`), and compression (`zlib`) are execution-blocked, so libuv executes them in its default thread pool (size 4, configurable via `UV_THREADPOOL_SIZE`).

Question 28

How do you write integration tests for database models in Node?

Accepted Answer

Use test databases (like memory databases or test MongoDB containers). In test setup phases (`beforeAll`), run migrations and seed data. Execute model actions, assert updates in the test database, and clear states in `afterAll` checks.

Question 29

Explain the role of Node.js Streams piping.

Accepted Answer

Piping (`readable.pipe(writable)`) connects readable streams to writable targets. It manages backpressure automatically: if the writable target is busy, the pipeline pauses the readable source, preventing memory overflows.

Question 30

What is event-loop block time and how do you monitor it?

Accepted Answer

Event-loop block time is the duration the main thread is blocked by synchronous tasks, delaying async callbacks. Monitor it using libraries like `blocked-at` or performance hook APIs (`perf_hooks`) to trace slow execution lines.

Question 31

Explain how to implement JSON Web Token (JWT) auth in Express middleware.

Accepted Answer

Write a middleware function that extracts the token from the `Authorization` header (`Bearer <token>`). Verify the signature using `jwt.verify(token, secret)`. If valid, attach the user payload to the request object and call `next()`; otherwise, return a 401 response.

Question 32

How do you write unit tests for modules that depend on fs?

Accepted Answer

Mock the file system module. In Jest, use `jest.mock('fs')` to mock file read and write operations, or use mock FS utilities (like `memfs`) to write files inside an in-memory virtual volume during tests.

Question 33

What is the purpose of the VM module in Node.js?

Accepted Answer

The `vm` module lets you compile and run JavaScript code inside V8 virtual machine contexts. It is useful for running untrusted user scripts in isolated sandbox environments, though it has security vulnerabilities.

Question 34

Explain the differences between http.createServer and https.createServer.

Accepted Answer

`http` handles unencrypted traffic over port 80. `https` handles encrypted traffic over port 443, requiring SSL/TLS certificate options (private key and certificate files) during server creation.

Question 35

How do you trace slow network connections inside Node.js applications?

Accepted Answer

Use Node's tracing module (`node --trace-events-enabled`). This outputs chrome tracing log files. Import logs into browser performance profile checkers to analyze socket open times and handler delays.

Question 36

What is the purpose of process.send() and IPC channels?

Accepted Answer

IPC (Inter-Process Communication) channels allow parent and child processes (spawned via `fork`) to communicate. Use `process.send({ msg: 'data' })` to pass serialized JSON payloads across processes.

Question 37

How do you verify test assertions for rejected promises?

Accepted Answer

In Jest, write async tests and assert failures using rejects: `await expect(asyncAction()).rejects.toThrow('Error')`. This ensures that promise rejections are verified correctly.

Question 38

Explain the V8 memory spaces (Young Generation, Old Generation, Large Object Space) and how to debug Heap Out of Memory errors.

Accepted Answer

V8 manages memory by dividing the Heap into spaces:
1. New Space (Young Generation): Small area (1-64MB) where allocations occur. Collected frequently using a fast Scavenge algorithm.
2. Old Space (Old Generation): Large area where surviving objects are promoted. Collected less frequently using Mark-Sweep-Compact.
3. Large Object Space: Used for objects larger than page sizes, bypassing normal GC sweeps.

Heap Out of Memory (OOM) errors occur when Node exceeds the memory limit (defaults to ~1.4GB on 64-bit systems). Debug this by starting Node with inspect tools, triggering heap dumps on crashes using `--write-heapprof-on-fatal-error`, and analyzing memory leak sources in Chrome DevTools. Increase limits using `--max-old-space-size=4096`.

Question 39

Explain how to build highly scalable websocket applications in Node.js with clustering and Redis adapter scaling.

Accepted Answer

WebSockets maintain persistent connections, meaning clustering creates issues since clients connected to server A cannot receive messages emitted by server B. To scale:
1. Spawning workers: Cluster Node instances using PM2 or the `cluster` module.
2. Redis Adapter: Integrate a Redis pub/sub adapter (like `socket.io-redis`). When server A emits an event, it publishes the event to Redis. Redis broadcasts the payload to all clustered server nodes, which transmit the message to their connected clients.
3. Load Balancing: Configure sticky sessions on load balancers (like Nginx) to route socket handshake requests to the same worker instance.

Question 40

How do you manage distributed logging and request correlation inside Node.js microservices?

Accepted Answer

Implement request correlation by injecting a unique correlation ID header (e.g. `X-Correlation-ID`) at the API Gateway level. Inside Node.js microservices, use OpenTelemetry with `AsyncLocalStorage` to store the correlation ID. Every database query or HTTP request to downstream services reads the ID from local storage and forwards it, allowing logs to be traced across all services.

Question 41

Explain security configurations of Node.js servers, focusing on CSRF, XSS, and SQL Injection mitigations.

Accepted Answer

Secure Node applications by:
1. Helmet: Use Helmet middleware to set secure HTTP headers (CSP, HSTS, X-Frame-Options).
2. CSRF: Store sessions in HttpOnly cookies, and require anti-CSRF tokens for mutating actions.
3. SQL Injection: Use parameterized queries or ORMs (like Prisma/Mongoose) to escape inputs, preventing attackers from injecting arbitrary DB queries.

Question 42

Explain how to handle CPU-bound tasks in Node.js without blocking the single-threaded event loop.

Accepted Answer

Do not execute CPU-bound tasks (like PDF parsing or zip compression) on the main event thread. Offload tasks by:
- Spawning Worker Threads (`worker_threads` module) to run JS code in background threads.
- Creating Child Processes (`child_process` module) to run external command tasks.
- Delegating tasks to external background queues (like BullMQ) backed by worker processes.

Question 43

Explain the architecture of Node.js stream buffering and watermarks.

Accepted Answer

Node streams buffer data in chunks. The `highWaterMark` option sets the buffer threshold (e.g. 16KB for readable streams). If the internal buffer is filled, the stream pauses loading data until it is read.

Question 44

How do you set up distributed tracing inside Node.js applications?

Accepted Answer

Install OpenTelemetry modules. Initialize tracing early in the entrypoint file to patch core packages (like `http`, `mongodb`, `redis`). Trace contexts are passed across requests using W3C Trace Context headers.

Question 45

Explain how to debug CPU bottlenecks inside Node.js production servers.

Accepted Answer

Capture CPU profiles. Run Node with `--cpu-prof`, or use APM tools to capture profiles under load. Import profiles into Chrome DevTools to locate slow synchronous JS code blocks.

Question 46

How does Node.js resolve circular dependencies and what are the runtime risks?

Accepted Answer

If module A requires module B, and B requires A, Node returns an unfinished copy of A's exports object to B to prevent infinite recursion, which can cause runtime crashes where imported functions evaluate to `undefined`.

Question 47

How do you optimize Node.js TLS context loading in high-traffic applications?

Accepted Answer

TLS handshake is CPU-intensive. Optimize by configuring SSL termination at the reverse proxy level (Nginx, Cloudflare), offloading encryption tasks from the Node server process entirely.

Question 48

Explain the differences between child_process exec and spawn.

Accepted Answer

- `exec()` buffers the entire command output in memory before returning it, which can crash if the output exceeds limits.
- `spawn()` streams output in real-time via stdout/stderr, utilizing less memory.

Question 49

How do you build a secure sandbox runner inside Node.js?

Accepted Answer

Use isolated sandboxing frameworks (like VM2 or isolated-vm). Run execution code in a separate OS thread or container with strict resource limits, disabling access to native modules (like `fs` or `net`).

Question 50

How does Node.js manage memory heap garbage collection statistics?

Accepted Answer

V8 publishes GC statistics using the `perf_hooks` module. Connect event listeners to trace garbage collection events, monitoring how much memory is recovered on sweeps to detect leaks.

Question 51

Explain how to write custom streams in Node.js.

Accepted Answer

Extend stream classes (e.g. `Readable`, `Writable`) and implement internal methods (like `_read()` or `_write()`), managing callback execution and backpressure triggers.

Question 52

How do you audit memory leak allocations inside production containers?

Accepted Answer

Start the Node container process with inspect flags. Port-forward the inspection port locally via SSH tunnels (`ssh -L 9229:localhost:9229 container-ip`), and attach Chrome DevTools to profile the process.

Question 53

Explain performance trade-offs of using AsyncLocalStorage in Node.

Accepted Answer

`AsyncLocalStorage` runs context tracking using V8 promise hooks. While useful for storing correlation IDs, it adds tracing overhead to async operations, which can degrade throughput slightly in high-QPS APIs.

Question 54

How do you implement secure rate-limiting on WebSocket handshakes?

Accepted Answer

WebSocket upgrades begin with standard HTTP GET requests. Intercept this upgrade request in Nginx or Express middleware, checking the client IP address in Redis before upgrading the connection.

Node.js Interview Questions for 2–5 Years Experience (2026)

What is Node.js and Why is it Critical in Modern Engineering?

Node.js Lifecycle Visualizer

Core Architectural Concepts in Node.js

V8 Engine Compilations

Event Loop Microtasks

Buffer & Stream Inputs

File System Operations

Cluster & Worker Threads

check_circleWhy Modern Companies Choose Node.js

lightbulbStrategic Preparation Tips

errorCrucial Mistakes to Avoid

trending_upHiring Trends & Career Outlook (2026)

Basics