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.

Node.js Interview Questions for Freshers (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