Node js Interview Questions

Node.js is considered fast because it uses the Google V8 JavaScript Engine, which compiles JavaScript directly into machine code instead of interpreting it line by line.

Another reason is its non-blocking, asynchronous architecture. Instead of waiting for one task to finish before starting another, Node.js continues executing other operations while long-running tasks (such as file reading or database queries) execute in the background.

console.log("Start");

setTimeout(() => {
    console.log("Task Completed");
}, 2000);

console.log("End");

Output
Start
End
Task Completed

The V8 Engine is Google's high-performance JavaScript engine, originally developed for the Chrome browser.

Node.js uses the V8 Engine to execute JavaScript outside the browser. Instead of interpreting JavaScript line by line, V8 converts JavaScript into optimized machine code using Just-In-Time (JIT) Compilation, resulting in much faster execution.

let sum = 10 + 20;
console.log(sum);

Output 
30

Traditional server-side technologies such as PHP or Java often use a multi-threaded model, where each incoming request gets its own thread. This can consume significant memory when handling many users.

Node.js follows a single-threaded event-driven architecture. It uses one main thread to receive requests and delegates long-running tasks (like file I/O or database operations) to the system, allowing it to handle many concurrent requests efficiently.

Synchronous programming executes tasks one after another. If one operation takes time, the entire program waits until it finishes.

Asynchronous programming allows long-running tasks to execute in the background while the rest of the program continues running. This is the default and recommended approach in Node.js.

The Event Loop is one of the core features of Node.js. It allows Node.js to perform non-blocking operations even though JavaScript runs on a single thread.

When an asynchronous task is started (such as reading a file or making an API request), Node.js sends it to the system APIs. Once the task completes, the Event Loop places the callback into the callback queue and executes it when the call stack is empty.

npm (Node Package Manager) is the default package manager for Node.js. It helps developers install, update, and manage third-party libraries and project dependencies.

When you initialize a Node.js project using npm init, npm creates a package.json file that stores project information and dependency details.

The package.json file is the configuration file for a Node.js project. It contains important information such as the project name, version, scripts, dependencies, author details, and more.

Whenever another developer clones your project, they can simply run npm install, and npm will install all dependencies listed in this file.

The Event Loop is the heart of Node.js. It enables Node.js to handle multiple asynchronous operations efficiently while using a single thread. Instead of waiting for one task to complete, Node.js registers asynchronous operations with the operating system and continues executing other code. Once an operation finishes, its callback is queued and executed by the Event Loop.

The Event Loop consists of six major phases:

1. Timers

2. Pending Callbacks

3. Idle/Prepare

4. Poll

5. Check

6. Close Callbacks

The Poll phase is the most important because it processes I/O events like file system and database operations.

Although all three schedule code to run later, they execute at different times in Node.js.

• process.nextTick() runs immediately after the current operation finishes, before the Event Loop continues.

• setImmediate() executes during the Check phase.

• setTimeout() executes during the Timers phase after the specified delay.

process.nextTick() has the highest priority.

console.log("Start");

process.nextTick(() => {
    console.log("nextTick");
});

setImmediate(() => {
    console.log("Immediate");
});

setTimeout(() => {
    console.log("Timeout");
}, 0);

console.log("End");

Output 
Start
End
nextTick
Timeout
Immediate

Node.js uses non-blocking asynchronous I/O. When a file read or database query is initiated, Node.js delegates the task to the operating system or libuv's thread pool instead of performing it on the main JavaScript thread.

While the operation is running, Node.js continues processing other requests. Once the task completes, its callback, Promise, or async function resumes execution.

This design enables Node.js to efficiently handle thousands of concurrent connections.

const fs = require("fs");

console.log("Start");

fs.readFile("test.txt", "utf8", (err, data) => {
    console.log(data);
});

console.log("End");

Output 
Start
End
File Content...

Node.js executes JavaScript on a single main thread, but it achieves concurrency by combining the Event Loop with libuv.

When asynchronous operations such as file reads, database queries, or HTTP requests are initiated, they are delegated to the operating system or libuv's worker threads. While these tasks are running, the main thread continues executing other JavaScript code.

This allows Node.js to serve many clients simultaneously without creating a thread for each request.

The JavaScript execution thread in Node.js is single-threaded. While asynchronous I/O does not block it, CPU-intensive tasks such as image processing, encryption, video transcoding, or large mathematical computations can block the Event Loop.

Worker Threads allow these CPU-heavy tasks to run in separate threads, keeping the main thread responsive.

Worker Threads should be used only for CPU-bound work, not for I/O operations.

const { Worker } = require("worker_threads");

new Worker("./worker.js");

Output 
Main Thread Running
Worker Started
Heavy Calculation Completed

Streams process data piece by piece (chunks) instead of loading the entire file into memory.

This approach is much more memory-efficient, especially when dealing with very large files such as videos, logs, or backups.

Node.js supports four types of streams:

• Readable Stream

• Writable Stream

• Duplex Stream

• Transform Stream

const fs = require("fs");

const stream = fs.createReadStream("video.mp4");

stream.on("data", chunk => {
    console.log(chunk.length);
});

Output
65536
65536
65536
...

Callbacks can become difficult to manage when multiple asynchronous operations depend on each other, leading to deeply nested code known as Callback Hell.

Promises provide a cleaner way to handle asynchronous operations using .then(), .catch(), and .finally(). They improve readability, simplify error handling, and work seamlessly with async/await.

async/await is built on top of Promises. An async function always returns a Promise, and the await keyword pauses execution within that function until the Promise resolves or rejects.

Importantly, await does not block the Event Loop. It only pauses the execution of the current async function while allowing Node.js to continue processing other requests.

This makes asynchronous code look and behave more like synchronous code, improving readability and maintainability.

function fetchUser() {
    return Promise.resolve("Sam");
}

async function getUser() {
    const user = await fetchUser();
    console.log(user);
}

getUser();

Output 
Sam

Node.js automatically manages memory using the V8 JavaScript Engine's Garbage Collector (GC). Whenever you create variables, objects, arrays, or functions, memory is allocated automatically.

When these objects are no longer referenced anywhere in the application, the Garbage Collector identifies them as unreachable and frees the memory.

The V8 engine mainly uses the Mark-and-Sweep Algorithm:

1. It starts from the root object.

2. Marks all reachable objects.

3. Removes objects that are not reachable.

4. Frees their memory.

This automatic memory management helps developers avoid manually freeing memory.

A Memory Leak occurs when memory that is no longer needed is not released. Over time, this increases memory usage and may eventually crash the application.

Common causes include:

• Global variables

• Uncleared timers (setInterval)

• Event listeners that are never removed

• Large cached objects

• Circular references

• Holding unnecessary references to objects

fs.readFile() loads the entire file into memory before your application can use it. This works well for small files but becomes inefficient for very large files.

Streams read data chunk by chunk, reducing memory usage and allowing processing to begin immediately.

For large files such as videos, backups, and logs, streams are the recommended approach.

A production-ready Node.js API should implement multiple security layers.

Some important security practices include:

• JWT Authentication

• HTTPS

• Helmet.js

• Rate Limiting

• Input Validation

• SQL Injection Prevention

• XSS Protection

• CSRF Protection

• Password Hashing using bcrypt

• Environment Variables

• CORS Configuration

JWT (JSON Web Token) is a secure way to authenticate users without storing session data on the server.

Workflow:

1. User logs in.

2. Server verifies credentials.

3. Server creates a JWT.

4. JWT is sent to the client.

5. Client stores the token.

6. Client sends the token with future requests.

7. Server verifies the token before allowing access.

These terms are often confused, but they serve different purposes.

Authentication verifies who the user is.

Authorization determines what the user is allowed to do after authentication.

Performance optimization is essential for scalable Node.js applications.

Common techniques include:

• Use asynchronous APIs

• Avoid blocking the Event Loop

• Implement caching (Redis)

• Use Streams

• Database indexing

• Compression (Gzip/Brotli)

• Connection Pooling

• Load Balancing

• Clustering

• Worker Threads for CPU-heavy tasks

• Pagination for large datasets

• Lazy Loading

• Efficient logging

• Avoid unnecessary synchronous methods

Whenever a client sends an HTTP request, Node.js follows several steps before returning a response.

1. Client sends an HTTP request.

2. The operating system accepts the TCP connection.

3. Node.js receives the request.

4. The Event Loop registers the request.

5. Middleware (Express) executes.

6. Route matching occurs.

7. Business logic executes.

8. Database/API calls are made asynchronously.

9. Response is prepared.

10. Response is sent back to the client.

Throughout this process, the Event Loop continues accepting new requests instead of waiting for one request to finish.

Middleware functions are executed in the order they are registered. Each middleware receives three parameters:

• req

• res

• next

Calling next() tells Express to continue to the next middleware. If next() is not called and no response is sent, the request remains pending.

Middleware is commonly used for:

• Authentication

• Logging

• Validation

• Error handling

• CORS

• File uploads

app.use((req, res, next) => {
    console.log("Middleware 1");
    next();
});

app.use((req, res, next) => {
    console.log("Middleware 2");
    next();
});

app.get("/", (req, res) => {
    res.send("Home");
});

Synchronous APIs block the Event Loop until the operation completes. While the Event Loop is blocked, Node.js cannot process any other incoming requests.

This significantly reduces application performance, especially under high traffic.

Asynchronous APIs should always be preferred in production because they allow the server to continue processing other requests.

Production debugging requires a structured approach instead of relying only on console.log().

Common techniques include:

• Node Inspector

• Chrome DevTools

• VS Code Debugger

• PM2 Monitoring

• Winston/Pino Logging

• Heap Snapshots

• CPU Profiling

• APM Tools (New Relic, Datadog)

• Process Monitoring

• Error Tracking (Sentry)

For production systems, structured logging and monitoring are far more effective than scattered console statements.

Redis is an in-memory data store commonly used for caching, session storage, and pub/sub messaging.

Instead of querying the database for every request, frequently accessed data is stored in Redis. Since Redis keeps data in RAM, responses are significantly faster.

Redis is commonly used for:

• API caching

• Session management

• Authentication tokens

• Leaderboards

• Real-time messaging