Advanced Node.js Interview Q&A

Are you preparing for a Node.js interview? Whether you are a beginner or looking to refresh your knowledge, this page covers Advanced Node.js questions that are commonly asked in interviews.

What is the difference between Monolithic and Microservices Architecture in Node.js?

Monolithic Architecture:

• Single codebase that handles the entire application (Frontend + Backend + Database).
• Difficult to scale and deploy large applications.
• Example: Traditional PHP or Laravel applications.

Microservices Architecture:

• Breaks the application into small independent services (user service, product service, payment service).
• Each service has its own database and runs independently.
• Easy to scale and maintain.
• Example: Netflix, Uber, Amazon use Microservices.

Explain the concept of Asynchronous Programming in Node.js.

Asynchronous Programming means executing tasks without blocking the main thread (event loop). Node.js handles this using:

1. Callbacks → Old method (prone to callback hell).
2. Promises → Better error handling and chaining.
3. Async/Await → Modern approach, cleaner code.

Example:

const fs = require('fs');

fs.readFile('file.txt', 'utf8', (err, data) => {
    if (err) throw err;
    console.log(data);
});

console.log('File read initiated');

Output:

File read initiated
(File contents)

Explain the concept of JWT (JSON Web Token) in Node.js.

JWT is used for stateless authentication (without sessions). It contains:

1. Header → Contains token type and algorithm.
2. Payload → Contains user data (like userId, email).
3. Signature → Verifies token authenticity.

Example of JWT Token:

const jwt = require('jsonwebtoken');

const token = jwt.sign({ id: 123 }, 'secretkey', { expiresIn: '1h' });
console.log(token);

const decoded = jwt.verify(token, 'secretkey');
console.log(decoded);

What is Middleware Chaining in Express.js?

Middleware chaining allows multiple middleware functions to execute in sequence using the next() function.

Example

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('Response');
});

Output

Middleware 1  
Middleware 2  
Response  

How to implement Rate Limiting in Node.js API?

Rate limiting prevents a user from making too many requests in a short time (avoiding DDoS attacks). Use the express-rate-limit package.

Example

const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // Limit each IP to 100 requests
});

app.use('/api/', limiter);

What is the difference between HTTP and WebSocket in Node.js?

WebSocket Example:

const WebSocket = require('ws');
const server = new WebSocket.Server({ port: 8080 });

server.on('connection', (socket) => {
    socket.send('Welcome!');
    socket.on('message', (message) => console.log(message));
});

Explain Load Balancing and Clustering in Node.js.

• Load Balancing distributes incoming traffic to multiple servers (horizontal scaling).
• Clustering uses the cluster module to create multiple Node.js processes on a single server.

Example:

const cluster = require('cluster');
const http = require('http');
const os = require('os');

if (cluster.isMaster) {
    os.cpus().forEach(() => cluster.fork());
} else {
    http.createServer((req, res) => {
        res.end('Hello World');
    }).listen(3000);
}

Each CPU core will handle one process, improving performance.

How to Secure Node.js Applications?

• Use HTTPS → Encrypt communication using HTTPS.
• Helmet.js → Secure HTTP headers.
• Rate Limiting → Prevent DDoS attacks.
• Avoid Exposing Errors → Use centralized error handling.
• Environment Variables → Store sensitive data (API Keys, DB Credentials).

Helmet.js Example:

const helmet = require('helmet');
app.use(helmet());

What is Event Emitter in Node.js?

EventEmitter is a core Node.js module that handles events asynchronously.

Example

const EventEmitter = require('events');
const emitter = new EventEmitter();

emitter.on('greet', (name) => {
    console.log(`Hello ${name}`);
});

emitter.emit('greet', 'John');

Output:

Hello John

What is Docker and How Can We Use It with Node.js?

Docker is a platform for packaging applications in containers that include:

• Application code
• Environment (Node.js, Nginx)
• Dependencies

Dockerfile Example:

FROM node:18
WORKDIR /app
COPY . .
RUN npm install
EXPOSE 3000
CMD ["node", "index.js"]

Build and Run:

docker build -t myapp .
docker run -p 3000:3000 myapp

What is the difference between Redis and MongoDB?

Redis Example:

const redis = require('redis');
const client = redis.createClient();

client.set('key', 'value');
client.get('key', (err, value) => console.log(value));

What is Dependency Injection in Node.js?

Dependency Injection (DI) is a design pattern that provides dependencies from outside rather than creating them inside.

Without DI:

const db = new Database();
const userService = new UserService(db);

With DI:

class UserService {
    constructor(database) {
        this.db = database;
    }
}

This makes the code more testable.

How to Handle Large File Uploads in Node.js?

For large file uploads, use streaming with multer or busboy

Example:

const multer = require('multer');
const upload = multer({ dest: 'uploads/' });

app.post('/upload', upload.single('file'), (req, res) => {
    res.send('File uploaded');
});

How to Implement WebSocket Authentication?

Authenticate WebSocket connection using JWT.

Client:

const socket = new WebSocket('ws://localhost:8080?token=JWT_TOKEN');

Server:

server.on('connection', (socket, req) => {
    const token = new URL(req.url, 'http://localhost').searchParams.get('token');
    const user = jwt.verify(token, 'secret');
    console.log(user);
});

Can Node.js Handle Multi-Threading?

Yes! Node.js uses:

1. Worker Threads → Execute code in parallel.
2. Cluster Module → Spawn multiple Node processes.

Example:

const { Worker } = require('worker_threads');
new Worker('./worker.js');