Advanced Node.js Interview Questions and Answers 2026

11. How do you handle CPU-intensive tasks?

CPU-intensive tasks can block the event loop, so they must be offloaded.

Approaches:

1. Worker Threads
2. Child Processes
3. External services (microservices)

Example (Worker Thread):

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

new Worker(`
  let sum = 0;
  for (let i = 0; i < 1e9; i++) sum += i;
  console.log(sum);
`, { eval: true });

Key idea:

Keep the main thread free for handling requests.

12. How do you measure async operation performance?

Methods:

1. performance API

const { performance } = require('perf_hooks');

const start = performance.now();

setTimeout(() => {
  console.log(performance.now() - start);
}, 100);

2. process.hrtime()

const start = process.hrtime();
// operation
const diff = process.hrtime(start);
console.log(diff);

3. Logging and monitoring tools

13. Which metrics should be monitored in production?

Key metrics:

• CPU usage
• Memory usage
• Event loop lag
• Response time
• Throughput (requests/sec)
• Error rate
• Database latency

Example:

console.log(process.memoryUsage());

14. How do you profile a Node.js application?

Tools:

1. Built-in profiler

node --inspect app.js

2. Chrome DevTools

• CPU profiling
• Heap snapshots

3. Clinic.js

• Flame graphs
• Bottleneck detection

15. What is load shedding?

Load shedding is a technique where the system intentionally rejects some requests to maintain stability under heavy load.

Example:

• Returning HTTP 503 when overloaded

Purpose:

• Prevent system crash
• Maintain performance for critical users

16. How do you handle traffic spikes?

Strategies:

1. Load balancing
2. Auto-scaling
3. Caching (Redis)
4. Rate limiting
5. Queueing systems (RabbitMQ)

17. How does Redis improve Node.js performance?

Redis is an in-memory database used for caching.

Benefits:

• Faster data access
• Reduces database load
• Improves response time

Example:

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

client.get("key", (err, data) => {
  if (data) return console.log(data);

  // fetch from DB and cache it
});

18. How would you architect a scalable Node.js application?

Key components:

1. Load balancer
2. Multiple Node.js instances (clustering)
3. Microservices architecture
4. Database scaling (replication/sharding)
5. Caching layer (Redis)
6. Queue system for background jobs

High-level flow:

Client → Load Balancer → Node servers → Cache/DB → Response

19. What design patterns are commonly used in Node.js?

Common patterns:

1. Singleton → single instance
2. Factory → object creation
3. Observer → event-based (EventEmitter)
4. Middleware pattern → request processing
5. Module pattern → encapsulation

20. What is the Reactor Pattern?

The Reactor Pattern is the design pattern used by Node.js to handle I/O operations.

Concept:

• Single thread listens for events
• Delegates tasks
• Executes callbacks when ready

Steps:

1. Event arrives
2. Event loop detects it
3. Handler (callback) is executed

Example concept:

setTimeout(() => {
  console.log("Handled asynchronously");
}, 1000);

Key idea:

• Efficient handling of multiple I/O operations without blocking 

21. What is CQRS?

CQRS (Command Query Responsibility Segregation) is a design pattern that separates read and write operations.

Concept:

• Command → modifies data (create, update, delete)
• Query → reads data

Why use it:

• Improves scalability
• Optimizes read/write performance separately
• Simplifies complex systems

Example:

// Command
app.post('/user', createUser);

// Query
app.get('/user/:id', getUser);

22. What is the Circuit Breaker pattern?

The Circuit Breaker pattern prevents repeated calls to a failing service.

States:

• Closed → normal operation
• Open → calls blocked
• Half-open → testing recovery

Purpose:

• Prevent system overload
• Improve fault tolerance

Example (concept):

if (serviceDown) {
  return "Fallback response";
}

23. How do you design idempotent APIs?

An API is idempotent if multiple identical requests produce the same result.

Techniques:

• Use unique request IDs
• Avoid duplicate operations
• Use PUT instead of POST when possible

Example:

app.put('/user/1', updateUser);

Calling it multiple times gives the same result.

24. How do you implement API versioning?

Methods:

1. URL versioning

/api/v1/users
/api/v2/users

2. Header versioning

Accept: application/vnd.myapi.v1+json

3. Query parameter

/users?version=1

Best practice:

Use URL versioning for simplicity.

25. What are microservices?

Microservices architecture breaks an application into small, independent services.

Characteristics:

• Each service handles a specific function
• Independently deployable
• Communicate via APIs

26. Why is Node.js suitable for microservices?

Node.js is suitable because:

• Lightweight and fast
• Non-blocking I/O
• Easy to build APIs
• Works well with JSON
• Large ecosystem

27. How do services communicate in microservices?

Methods:

1. HTTP/REST APIs
2. Message queues (async)
3. gRPC

Example:

axios.get('http://user-service/users');

28. What is eventual consistency?

Eventual consistency means that data will become consistent over time, not immediately.

Used in:

• Distributed systems
• Microservices

Example:

• Order placed → inventory updates later

29. How do you implement message queues?

Message queues allow asynchronous communication between services.

Tools:

• RabbitMQ
• Kafka

Example (RabbitMQ concept):

channel.sendToQueue('task_queue', Buffer.from('message'));

Flow:

Producer → Queue → Consumer

31. Difference between Kafka and RabbitMQ (Node.js perspective)

Apache Kafka vs RabbitMQ

Summary:

• Kafka → large-scale streaming systems
• RabbitMQ → simple message queuing

if (retryCount < 3) {
  retryMessage();
} else {
  moveToDLQ(message);
}

function auth(req, res, next) {
  if (!req.user) return res.status(401).send("Unauthorized");
  next();
}

function authorize(role) {
  return (req, res, next) => {
    if (req.user.role !== role) return res.status(403).send("Forbidden");
    next();
  };
}

const https = require('https');
const fs = require('fs');

const options = {
  key: fs.readFileSync('key.pem'),
  cert: fs.readFileSync('cert.pem')
};

https.createServer(options, (req, res) => {
  res.end("Secure server");
}).listen(443);

const crypto = require('crypto');

const hash = crypto.createHash('sha256')
  .update('data')
  .digest('hex');

console.log(hash);

console.log(JSON.stringify({
  level: "info",
  message: "User logged in",
  userId: 1
}));

process.on('SIGTERM', () => {
  server.close(() => {
    console.log("Server closed");
  });
});

console.log(process.memoryUsage());