Top 100 Node.js Interview Questions and Answers

Node.js is a server-side JavaScript runtime environment that allows you to execute code outside of a web browser. While a browser's runtime is for front-end web development, Node.js is for building back-end services, command-line tools, and network applications.

The V8 JavaScript engine compiles JavaScript code into machine code, allowing Node.js to execute it very quickly. It's the same engine used in Chrome, which is why Node.js is so fast.

Node.js is single-threaded in that it has only one main thread for code execution. However, it handles asynchronous operations using the event loop. When an I/O operation (like reading a file) is requested, Node.js offloads it to a separate thread pool. The event loop then continues with other tasks and, when the I/O operation is complete, a callback function is put on the event queue to be executed.

You can create a simple web server by using the http module. You use http.createServer() to create the server and then server.listen() to start it on a specific port.

Blocking code execution stops the entire process until a task is complete. Non-blocking code execution, on the other hand, allows the process to continue with other tasks while an operation (like an I/O request) is being handled in the background.

The require() function is used to load and cache node module files. For example, const http = require('http'); imports the built-in module (“http”) into your code.

Node Package Manager (NPM) is a package management tool for Node.js. You use it via the command line interface to install, update, and manage dependencies for your projects.

A local installation (npm install <package_name>) installs the package in the node_modules folder of your current project, making it available only to that project. A global installation (npm install -g <package_name>) installs the package in a system-wide folder, making it available to all projects and accessible from the command line.

The package.json file holds metadata about a project, including its name, version, and scripts. Most importantly, it lists the project's dependencies, making it easy to share and reproduce the project environment.

A common convention for error handling with a callback function is the "error-first callback" pattern. The first argument of the callback function is reserved for an error parameter, which will be null if the operation was successful.

Promises are objects that represent the eventual completion or failure of an asynchronous operation. They address callback hell by providing a cleaner, more readable way to chain async functions.

async/await is a syntactic sugar built on top of Promises. It allows you to write asynchronous code that looks and behaves like synchronous code, making it much easier to read and maintain.

The fs module provides api functions for interacting with the file system. For example, you can use fs.readFile() to read a file or fs.writeFile() to write data.

Synchronous file system operations block the event loop until they are complete. Async operations, on the other hand, don't block the event loop; they take a callback function that is executed when the operation is finished.

The buffer class is used to represent a raw memory allocation outside the V8 heap. It's essential for handling binary data, such as images or encrypted information.

A stream is an abstract interface for working with streaming data. It's particularly useful when dealing with large files or network communication, as it allows you to process data in small chunks rather than loading it all into memory at once.

The EventEmitter is a class in Node.js that allows you to create custom events and listen for them. It's a key part of event-driven programming, enabling objects to communicate with each other through a notification mechanism.

process.nextTick() schedules a callback function immediately to be executed on the current event loop cycle, before any I/O. setImmediate() schedules a callback to be executed in the next cycle of the event loop.

You can access env variables using the process.env object. For example, process.env.PORT would give you the value of the PORT environment variable. You can also take advantage of the dotenv module, which parses .env files in your local folder and turns their content into environment variables during the execution of your scripts.

A middleware function is a function that has access to the request and response objects and can modify them or terminate the request-response cycle. It's often used for tasks like authentication, logging, and error handling.

You define a route using the app.<method>(path, callback) syntax, where <method> is the HTTP verb (get, post, put, delete, etc.), path is the URL, and callback is the handler for the HTTP request.

module.exports is the actual object that is returned from a require() call. exports is a reference to module.exports. If you want to export a single object or class, you should use module.exports. If you want to export multiple things, you can add properties to the exports object.

The read-eval-print loop (REPL) is an interactive CLI tool that lets you execute code one line at a time. It's useful for testing small snippets of code and exploring the built-in Node object methods.

You can debug a Node.js application using the built-in debugger (node inspect) or by using an integrated debugger in a code editor like VS Code.

Some common Node.js API functions include fs.readFile(), http.createServer(), path.join(), and os.cpus().

An error-first callback is a pattern used to create functions where the first argument is an error object. If an error occurred, that object will contain details about it; otherwise, it will be null. You can use this pattern when dealing with callback-dependent logic in your code.

This queue (also known as “callback queue”) is where callback functions are placed after an asynchronous operation completes. The event loop checks the queue and executes these callbacks one by one when the main thread is free.

Node.js handles many requests at the same time efficiently because of its non-blocking I/O and the event loop. When an incoming request requires an asynchronous operation, Node.js doesn't wait; it offloads the task and processes the next request. The associated callback function for the first request is executed later, once the operation is finished.

You can execute code from a file by running the command node <filename.js> in your terminal.

A control flow function is a function that manages the order of execution of other functions, especially in asynchronous programming, to ensure that tasks are performed in the correct sequence.

The most effective way to avoid callback hell is to use Promises or async/await. These patterns allow you to chain async function calls in a much more readable, sequential manner, making the control flow of your application easier to manage.

EDP is a paradigm where the flow of a program is determined by events, such as user actions, sensor outputs, or messages from other programs. Node.js is naturally suited for this, as it uses the event emitter to fire events and allows other parts of the application to respond to them via event listeners.

The event loop has several distinct phases: timers, pending callbacks, idle/prepare, poll, check, and close callbacks. The poll phase is the most important; it retrieves new I/O events and executes their callbacks.

The event loop has a specific order of operation. For example, process.nextTick() callbacks are executed before any other events in the same cycle, while setImmediate() callbacks are executed in the subsequent cycle. Timers have their own queue and are executed as close as possible to their scheduled time.

Libuv is a C++ library that provides Node.js with its non-blocking I/O functionality. It's responsible for managing the pool of threads, which handles I/O tasks in the background, freeing up the main single thread to handle more requests.

child_process.spawn() launches a new process with a specific command, streaming its I/O. child_process.fork(), on the other hand, is a special case of spawn() that's designed for Node.js modules. It establishes a communication channel between the parent and child processes, allowing them to exchange messages.

Worker threads are ideal for CPU-intensive tasks that would otherwise block the main single thread. Unlike child processes, they share memory, making it easier to exchange data, but they should only be used for computation, not I/O.

Node.js uses the V8 engine's garbage collector. It works in two phases: the "Scavenge" phase for new objects and the "Mark-Sweep" and "Mark-Compact" phases for older, more persistent objects.

Common vulnerabilities include cross-site scripting (XSS), SQL injection, and insecure dependencies. You can mitigate these by using security middleware, validating all user input, and regularly updating your node package manager dependencies.

You can handle sessions and authentication using libraries like Passport.js. It's common to use JSON Web Tokens (JWT) for stateless authentication or session-based authentication with a session store like Redis.

CORS is a security feature that prevents a web page from making requests to a different domain. You can handle it on a Node.js web server by setting specific HTTP headers or by using a middleware library like the cors package in Express.js.

You can connect to a database using a dedicated Node.js module for that database (e.g., pg for PostgreSQL or mongoose for MongoDB). These libraries provide an API to establish a connection, execute queries, and handle the results.

You can use a linter like ESLint to automatically check for and report on code that doesn't follow a specific, consistent code style. It can be integrated into your development workflow and CLI tool to ensure everyone adheres to the same standards.

Express.js simplifies the process of building a web server by providing a robust set of features, including routing, middleware, and templating. It saves a lot of boilerplate work that would be required with the native HTTP module.

You can handle errors in Express.js using a dedicated error-handling middleware with four arguments: (err, req, res, next). This function is executed when an error is passed to next(), allowing you to centralize your error responses.

A router in Express.js is a modular, mini-application that can handle specific routes. It helps you organize your application by grouping related routes and middlewares together, making your code more maintainable.

You can access command line interface arguments through the process.argv array. The first two elements are the Node.js path and the script path, respectively; subsequent elements are the arguments passed by the user.

process.env.NODE_ENV is a crucial environment variable that signals to your application whether it's running in a development, production, or testing environment. Many node module dependencies and frameworks use this variable to optimize their behavior.

It's best practice to use env variables to store sensitive information like API keys and database credentials. You can use a library like dotenv for development, and a service like Vault or a cloud provider's secret manager for production.

Clustering allows you to take advantage of multi-core systems by creating multiple instances of your Node.js application. The cluster module uses a master process to manage worker processes, distributing incoming load among them and ensuring high availability.

You test a Node.js application by writing unit tests, integration tests, and end-to-end tests. Popular testing frameworks include Jest, Mocha, and Chai.

The Test Pyramid is a testing strategy that suggests you should have a large number of fast-running unit tests, a smaller number of integration tests, and a very small number of slow end-to-end tests. This approach ensures a quick feedback cycle while still providing full coverage.

GraphQL is a query language for your API. Unlike a REST API, which has fixed data structures for its endpoints, GraphQL allows the client to request exactly the data it needs, leading to more efficient endpoints and reduced over-fetching (when you request more information than what you actually need).

You would use a middleware designed for handling multipart/form-data requests, such as multer. multer parses the incoming request and makes the file available to your route handler, which can then save it to the file system.

A WebSocket provides a full-duplex communication channel over a single TCP connection. It's useful for real-time applications like chat apps or live dashboards, where you need a persistent connection and two-way communication without the overhead of repeated HTTP request cycles.

You can use Promises with Promise.all() to run multiple tasks concurrently and wait for all of them to complete. This is much more efficient than waiting for one task to finish before starting the next.

Node.js typically communicates with external services via HTTP requests using the native http module or a JavaScript library like axios or node-fetch. You can also use other protocols like gRPC for high-performance communication.

The crypto module provides cryptographic functionality, including hashing, encryption, and decryption. It's used to secure sensitive data, such as user passwords and API tokens.

The thread pool is part of libuv and is used to offload blocking tasks into multiple threads, such as complex calculations or I/O operations, from the main single thread. This allows the event loop to continue processing other requests without being blocked.

Promises and async/await provide a structured way to manage control flow in an asynchronous programming environment. async/await allows you to write sequential-looking code that pauses execution until a Promise resolves, while Promises themselves allow for powerful chaining and parallel execution.

I would use a modular architecture, breaking the application into smaller, single-purpose components. I would also leverage microservices or serverless patterns for scalability, use a message queue for inter-service communication, and implement a clear separation of concerns to ensure maintainability.

Microservices is an architectural style where a large application is broken down into a collection of small, independent services. Node.js is a great fit because its event-driven programming model and efficiency with I/O-bound tasks allow it to handle many different requests and communicate between services effectively.

There are several ways. You can use HTTP servers with RESTful endpoints, but for better performance and reliability, I prefer message queues (like RabbitMQ or Kafka) or a high-performance framework like gRPC.

Pros: No server management, auto-scaling, and a pay-per-use model that can reduce costs. Cons: Vendor lock-in, cold start latency, and potential for more complex debugging and deployment.

I would use a combination of logging, metrics, and tracing. I would use a centralized logging service (e.g., Elastic Stack) to collect and analyze application logs, a metrics service (e.g., Prometheus) to track performance, and a tracing tool (e.g., OpenTelemetry) to trace requests across different services.

The best practice is to offload these tasks to other processes or services so they don't block the main single thread. I would use worker threads for in-process computation or a dedicated child process for more isolated tasks.

I would start by implementing caching (at the application or database level), using clustering to utilize all available CPU cores, and optimizing database queries. I'd also ensure that I'm using non-blocking I/O and modern asynchronous programming techniques.

TypeScript adds static typing to your JavaScript syntax, which helps catch bugs early in development. It also provides better tooling, improved readability, and makes your codebase more robust and easier to refactor, especially in large-scale applications.

I would use a CI/CD platform like Jenkins, GitHub Actions, or GitLab CI. The pipeline would include steps to install dependencies, run tests, build a Docker image, and then deploy the container to a staging or production environment.

spawn() launches a new process, and you get a stream to its stdin, stdout, and stderr. fork() is a special case of spawn() that is specifically for spawning Node.js processes. It includes a communication channel, allowing the parent and child to pass messages between them.

You can prevent resource starvation by ensuring that I/O operations have a timeout and that you handle them gracefully. Using a well-managed thread pool and load balancing across many different instances also helps.

You could use a middleware like helmet to automatically set a number of security-related HTTP headers, such as X-Content-Type-Options, Content-Security-Policy, and Strict-Transport-Security.

OpenTelemetry is an open-source observability framework for generating and collecting telemetry data (metrics, logs, and traces). Its role is to provide a standardized way to instrument applications, making it easier to monitor and troubleshoot distributed systems.

You can use the process.on('uncaughtException', ...) event listener, but the recommended approach is to have a dedicated domain or middleware to catch errors and gracefully shut down the application.

The Node.js single-threaded process model is great for I/O-bound applications, as it can handle a large number of concurrent connections efficiently. For CPU-intensive tasks, however, it can be a bottleneck, which is why we use clustering or worker threads to scale.

The require.resolve() function is used to find the full path to a module without actually loading it. It follows the same module resolution algorithm as require() but returns the resolved file path instead of the module itself. You would typically use require.resolve() in scenarios where you need to check if a module is available or to get its path for some other operation, such as dynamically loading a module or checking its location on the file system. This can be useful for tools or build systems that need to locate dependencies without the side effects of loading the module immediately.

You can use a load balancer (e.g., Nginx, HAProxy) to distribute multiple requests across different instances of your application. These instances would typically be running on different machines or containers to ensure high availability.

The reactor pattern is an I/O handling design pattern. It's a key part of how Node.js works, as it handles a large number of concurrent connections with a single thread by demultiplexing incoming events and dispatching them to their respective handlers.

The zlib module provides compression and decompression functionality. It's significant because it's the module that Express.js's compression middleware uses to compress HTTP servers responses, which reduces bandwidth and speeds up page load times.

The net module is for creating TCP servers and clients, allowing for streaming communication. The dgram module is for UDP datagram sockets, which are useful for applications where data delivery isn't guaranteed, like gaming or streaming.

Docker is a containerization platform that packages your application and all its dependencies into a single, isolated container. You can use it to deploy Node.js applications by creating a Dockerfile that specifies how to build an image with your code and dependencies.

For rate-limiting an API, you could use a middleware such as express-rate-limit to restrict the number of requests a user can make to an API over a period of time. This prevents abuse, protects your resources, and ensures fair usage for all clients.

Bun is an all-in-one JavaScript runtime with a focus on speed and built-in tools. Deno is a secure runtime that uses TypeScript by default and has a different module system. Node.js is the original, most mature runtime with the largest ecosystem.

I would use a connection pool. A connection pool maintains a set of open connections to the database, allowing your application to reuse them instead of creating a new connection for every request, which is much more efficient.

A message queue is useful for decoupling services. Instead of one service directly calling another, it can send a message to a queue. This is great for handling long-running or background tasks, as it prevents the event loop from being blocked.

While async/await improves readability, it can sometimes be slightly less performant than raw Promises due to the overhead of generating the state machine. However, the performance difference is usually negligible, and the code clarity is well worth the trade-off.

I would use an in-memory cache like node-cache or a more robust solution like Redis. You can implement a middleware function that checks the cache for a response before it hits your route handler and, if not found, stores the result after the handler completes.

esbuild is a very fast JavaScript bundler and minifier. It relates to Node.js as a tool for preparing your code for production, making it smaller and faster to load.

Event delegation is a pattern where, instead of adding an event listener to every single element, you add one to a parent element. When a child element is clicked, the event bubbles up to the parent, and you can determine which child was clicked.

The V8 engine uses Just-In-Time (JIT) compilation. It parses the JavaScript code and converts it into a lower-level intermediate representation. It then uses a fast compiler to generate unoptimized machine code. If a function is run often, it's passed to an optimizing compiler to generate faster, more efficient machine code.

JWT is a compact, URL-safe means of representing claims to be transferred between two parties. In Node.js, you would use a library like jsonwebtoken to create a JWT upon successful authentication. The token is then sent to the client, which includes it in subsequent requests for authorization.

I would use a Node.js module like i18next or react-intl. These libraries help you manage translations, format dates and numbers according to different locales, and serve the appropriate content based on the user's language settings.

SSR is when a web page's HTML is generated on the server for each request. You would use it for better SEO (since search engine crawlers can easily read the content) and improved initial load times, especially for complex applications.

A monolithic architecture is simpler to develop and deploy initially, but it can become harder to scale and maintain over time. A microservices architecture is more complex to set up but offers greater scalability, resilience, and maintainability in the long run.

You can protect against DDoS attacks by using a reverse proxy (e.g., Nginx) or a CDN (e.g., Cloudflare) to absorb and filter malicious traffic before it reaches your http server. Implementing rate-limiting is also a good practice.

The util module provides utility functions for a variety of tasks, such as inspecting objects, converting callback function-based APIs to Promise-based APIs, and more.

Telemetry is the process of collecting data about an application's performance, health, and behavior. It's crucial for understanding how your application is performing in production, identifying bottlenecks, and debugging issues.

Promise.all() is significant because it allows you to run multiple promises concurrently and wait for all of them to resolve before continuing. Promise.race() is for executing multiple promises and acting on the first one that either resolves or rejects.

setTimeout(fn, 0) schedules a task to be run as soon as possible after the current event loop cycle, but it's subject to a minimum delay. setImmediate(), on the other hand, runs its task in the next cycle of the event loop, making it more predictable for I/O-based tasks.

I would follow the official Node.js blog and release notes, listen to podcasts, read articles from influential developers, and participate in community discussions and conferences.