1. What is the "Event Loop" and how does it work in Node.js?

The Event Loop is a single-threaded loop that allows Node.js to perform non-blocking I/O operations. It offloads tasks to the system kernel whenever possible. It has 6 main phases: Timers, Pending Callbacks, Idle/Prepare, Poll, Check, and Close Callbacks.

2. Explain the "Reactor Pattern".

The Reactor Pattern is a design pattern used in Node.js for building scalable non-blocking I/O. It involves a "Resources" (like a socket), a "Synchronous Event Demultiplexer" (like epoll or kqueue), and a "Request Handler" (with a callback).

3. What is "Libuv" and why is it essential?

Libuv is a multi-platform C library that provides support for asynchronous I/O based on event loops. It handles the thread pool, file system I/O, DNS lookup, and child processes, effectively making Node.js performant.

4. How does "Node.js Thread Pool" work?

While the Event Loop is single-threaded, Libuv maintains a thread pool (default size is 4) for executing heavy tasks that are not natively asynchronous (like file I/O, crypto, or compression). You can increase this size using process.env.UV_THREADPOOL_SIZE.

5. What is the difference between `process.nextTick()` and `setImmediate()`?

process.nextTick(): Executes immediately after the current operation finishes, before the Event Loop moves to the next phase.
setImmediate(): Executes in the "Check" phase of the next Event Loop cycle, after the "Poll" phase.

6. What are "Streams" and why are they better than `fs.readFile`?

Streams are an abstract interface for working with streaming data. They allow you to process data piece by piece without loading the entire file into memory, which is crucial for handling large files or low-memory environments.

7. Explain "Backpressure" in Streams.

Backpressure occurs when a writable stream is being overwhelmed by a faster readable stream. The writable stream sends a signal (returns false from .write()) to the readable stream to stop sending data until it has caught up.

8. What is the difference between "Cluster" and "Worker Threads"?

Cluster: Spawns multiple identical processes, each with its own memory and event loop, sharing the same server port. Best for scaling across CPU cores.
Worker Threads: Runs multiple threads within a single process, sharing memory. Best for CPU-intensive tasks without blocking the main event loop.

9. How do you handle "Uncaught Exceptions" and "Unhandled Rejections"?

Use process.on('uncaughtException', ...) and process.on('unhandledRejection', ...). However, it's best practice to allow the process to crash and restart via a process manager (like PM2) after logging the error.

10. Explain "Memory Leaks" in Node.js and how to find them.

Memory leaks occur when objects are no longer needed but are still reachable from the roots. You can find them using the built-in node --inspect flag and Chrome DevTools to take heap snapshots and compare them.

11. What is the "V8 Engine" and how does it optimize JavaScript?

V8 is Google's open-source JavaScript engine. It uses "Just-In-Time" (JIT) compilation to turn JS into machine code. It optimizes code by identifying "hot" functions and using polymorphic vs monomorphic check optimizations.

12. What is "Buffer" and why do we need it?

Buffers are blocks of memory outside the V8 heap used to handle raw binary data (like images, video, or TCP streams) efficiently.

13. How do you implement "Graceful Shutdown" in Node.js?

By listening for termination signals (like SIGTERM or SIGINT), stopping the server from accepting new connections, finishing existing requests, and then closing database connections before calling process.exit(0).

14. What are "CJS" vs "ESM" in Node.js?

CommonJS (CJS): Uses require() and module.exports; synchronous; default for years.
EcmaScript Modules (ESM): Uses import and export; asynchronous; the modern standard.

15. Explain "Microservices Interaction" patterns in Node.js.

Common patterns include Request/Response (REST, gRPC) for synchronous communication and Pub/Sub (RabbitMQ, Kafka, Redis) for asynchronous event-driven communication.

16. What is "gRPC" and why is it used in Node.js?

gRPC is a high-performance RPC framework developed by Google. It uses Protocol Buffers (binary data) instead of JSON, making it significantly faster and more typed than traditional REST APIs for internal service communication.

17. How do you secure a Node.js API?

Use helmet for secure HTTP headers.
Implement rate-limiting.
Sanitize inputs against XSS and SQLi.
Use npm audit to check for vulnerable dependencies.

18. What is "Piping" in Node.js?

A mechanism to connect the output of a readable stream directly to the input of a writable stream (e.g., readable.pipe(writable)), handling backpressure automatically.

19. Explain "AbortController" usage in Node.js.

It allows you to cancel asynchronous operations (like fetch requests or fs operations) when they are no longer needed, preventing resource leaks.

20. What is "Dependency Injection" in Node.js?

A design pattern where a module's dependencies are passed in as arguments rather than being required internally. This makes the code more testable and modular.

21. How do you perform "Clustering" without external tools?

Using the built-in cluster module to spawn one worker process for each CPU core. The master process manages the workers and restarts them if they fail.

22. What is "REPL" (Read-Eval-Print Loop)?

The interactive shell for experimenting with Node.js code. You can start it by typing node in your terminal without any arguments.

23. Explain "Child Processes" and their types.

spawn(): For long-running processes that output large amounts of data.
exec(): For short-running processes where you expect a buffer of output.
fork(): A special case of spawn() specifically for creating new Node.js processes.

24. What are "Environment Variables" and how to manage them safely?

Stored in .env files and accessed via process.env. Use libraries like dotenv for development and native secret managers (like AWS Secrets Manager) for production.

25. How do you optimize "I/O Performance" in Node.js?

Use non-blocking APIs.
Implement caching (Redis).
Use compression (Gzip/Brotli).
Use HTTP/2 for faster multiplexed connections.

26. What is "SemVer" (Semantic Versioning)?

A versioning system (MAJOR.MINOR.PATCH) that tells you the risk of updating a package. ^ and ~ in package.json control how npm updates packages.

27. What is "NPM Audit"?

A built-in command that checks your package-lock.json against a database of known vulnerabilities and suggests fixes.

28. Explain "N-API" (Node-API).

An API for building native Node.js addons that is independent of the underlying JavaScript engine. This ensures that addons don't need to be recompiled for every major Node version.

29. What is "Zero-Downtime Deployment"?

A deployment strategy where new versions are rolled out without interrupting service, often achieved via Blue-Green deployments or rolling restarts in a cluster.

30. What is "Garbage Collection" (GC) types in V8?

Scavenge: Fast, for young objects.
Mark-Sweep-Compact: Heavier, for older objects that have survived multiple scavenges.

31. How do you read "Command Line Arguments"?

Using the process.argv array, or better yet, using libraries like yargs or commander for complex parsing.

32. What is "Cross-Origin Resource Sharing" (CORS)?

A security mechanism to allow or restricted resource requests from another domain. In Express, it's typically handled by the cors middleware.

33. Explain "JWT" (JSON Web Token) flow.

User logs in.
Server signs a token with a secret and returns it.
User sends the token in the Authorization header for subsequent requests.
Server verifies the signature without needing a database session lookup.

34. What is "Bcrypt" and why is it preferred for passwords?

A hashing function specifically designed for passwords. It is "saltable" and intentionally slow (configurable work factor) to protect against brute-force attacks.

35. Explain "Zlib" usage.

A built-in module providing compression and decompression (Gzip, Deflate, Brotli) for reducing the size of data transmitted over the network.

36. What is "Module Caching"?

When you require() a file for the first time, Node.js caches it in require.cache. Subsequent calls return the same exported object, making it like a singleton.

37. What is `__dirname` vs `process.cwd()`?

__dirname: The absolute path of the directory where the current file is located.
process.cwd(): The absolute path of the directory from which the Node.js process was started.

38. How do you implement "Rate Limiting"?

Using middleware like express-rate-limit combined with a fast store like Redis to track and block requests from an IP if they exceed a certain threshold.

39. What is "Passport.js" and why is it popular?

An authentication middleware that provides 500+ "strategies" (local, Google, GitHub, etc.) to integrate social and local logins into Node.js apps.

40. Explain "Logging" best practices.

Use structured logging (JSON) with libraries like pino or winston.
Log at appropriate levels (debug, info, warn, error).
Send logs to a central management system (ELK stack, Datadog).

41. What is "Testing Frameworks" landscape?

Mocha/Chai: Flexible, classic choice.
Jest: All-in-one, highly popular (built-in mocking and coverage).
Supertest: For testing HTTP endpoints.

42. What is "Code Coverage"?

A measurement of how much of your source code is executed when tests are run (using tools like nyc or Jest's built-in reporter).

43. Explain "Domain" (Deprecated) vs "Async Local Storage".

Async Local Storage is the modern way to store data (like a request ID or user info) throughout an asynchronous execution flow without passing it explicitly through every function.

44. What is "Package.json" vs "Package-lock.json"?

package.json: Lists dependencies and scripts; allows range versions.
package-lock.json: Records the exact version of every package installed, ensuring reproducible builds.

45. What is "WebSockets" in Node.js?

A protocol providing full-duplex communication over a single TCP connection. Commonly implemented with socket.io for real-time features like chat or live updates.

46. Explain "Error-First Callbacks".

A standard pattern where the first argument of a callback is an error object (or null) and the second is the data. It's the foundation of Node.js asynchronous handling.

47. What is "EventEmitter" and "Custom Events"?

A built-in class for handling events. You can create your own objects that emit events and set up listeners to react to them.

48. What is "PM2" and how does it help?

A production process manager that provides automatic restarts on crashes, monitoring, and zero-downtime reloads.

49. How do you handle "Sensitive Data" in logs?

By using "Redaction" in your logger configuration to automatically mask fields like passwords, credit card numbers, or API keys before they are written.

50. Why is Node.js used for "High I/O" applications?

Because its non-blocking, event-driven architecture allows a single thread to handle thousands of concurrent connections without the overhead of thread context switching.

Node.js Interview Questions

Table of Contents

What is the "Event Loop" and how does it work in Node.js?

Explain the "Reactor Pattern".

What is "Libuv" and why is it essential?

How does "Node.js Thread Pool" work?

What is the difference between <code>process.nextTick()</code> and <code>setImmediate()</code>?

What are "Streams" and why are they better than <code>fs.readFile</code>?

Explain "Backpressure" in Streams.

What is the difference between "Cluster" and "Worker Threads"?

How do you handle "Uncaught Exceptions" and "Unhandled Rejections"?

Explain "Memory Leaks" in Node.js and how to find them.

What is the "V8 Engine" and how does it optimize JavaScript?

What is "Buffer" and why do we need it?

How do you implement "Graceful Shutdown" in Node.js?

What are "CJS" vs "ESM" in Node.js?

Explain "Microservices Interaction" patterns in Node.js.

What is "gRPC" and why is it used in Node.js?

How do you secure a Node.js API?

What is "Piping" in Node.js?

Explain "AbortController" usage in Node.js.

What is "Dependency Injection" in Node.js?

How do you perform "Clustering" without external tools?

What is "REPL" (Read-Eval-Print Loop)?

Explain "Child Processes" and their types.

What are "Environment Variables" and how to manage them safely?

How do you optimize "I/O Performance" in Node.js?

What is "SemVer" (Semantic Versioning)?

What is "NPM Audit"?

Explain "N-API" (Node-API).

What is "Zero-Downtime Deployment"?

What is "Garbage Collection" (GC) types in V8?

How do you read "Command Line Arguments"?

What is "Cross-Origin Resource Sharing" (CORS)?

Explain "JWT" (JSON Web Token) flow.

What is "Bcrypt" and why is it preferred for passwords?

Explain "Zlib" usage.

What is "Module Caching"?

What is <code>__dirname</code> vs <code>process.cwd()</code>?

How do you implement "Rate Limiting"?

What is "Passport.js" and why is it popular?

Explain "Logging" best practices.

What is "Testing Frameworks" landscape?

What is "Code Coverage"?

Explain "Domain" (Deprecated) vs "Async Local Storage".

What is "Package.json" vs "Package-lock.json"?

What is "WebSockets" in Node.js?

Explain "Error-First Callbacks".

What is "EventEmitter" and "Custom Events"?

What is "PM2" and how does it help?

How do you handle "Sensitive Data" in logs?

Why is Node.js used for "High I/O" applications?