Node.js Event Loop Explained: How It Works with Examples

What Is the Node.js Event Loop?

Node.js is a JavaScript runtime built on Chrome’s V8 JavaScript engine. It is widely used to develop server-side applications, REST APIs, real-time systems, and other applications that need to handle multiple operations efficiently.

One of the most important concepts in Node.js is the event loop. It allows Node.js to manage asynchronous operations without blocking JavaScript execution while waiting for many types of I/O tasks to finish.

For example, imagine a web application receiving several requests at the same time. Some requests may need to retrieve information from a database, read a file, or communicate with an external service. Instead of making JavaScript wait for every operation to finish, Node.js can initiate asynchronous work and continue processing other tasks when possible.

Understanding the event loop helps developers write responsive applications, identify performance bottlenecks, and manage asynchronous code more effectively.

Why Is the Event Loop Important?

The event loop is essential because it coordinates the execution of JavaScript callbacks and helps Node.js process asynchronous work.

Its main benefits include:

• Efficient I/O handling: Applications can perform many network and file operations without waiting synchronously for each one to finish.

• Responsiveness: The main JavaScript thread can continue processing work while asynchronous operations are pending.

• Scalability: Node.js can support many concurrent connections when the application is designed efficiently.

• Better performance management: Understanding the event loop helps developers identify blocking code and improve application responsiveness.

However, the event loop does not make every operation automatically faster. Long-running JavaScript computations can still block the main thread and delay other callbacks.

How Does the Node.js Event Loop Work?

The Node.js event loop coordinates JavaScript execution with asynchronous operations managed by the runtime and its underlying libraries. To understand it, you should first learn about the call stack, the event loop, and the role of the operating system and libuv.

1. The Call Stack

The call stack keeps track of JavaScript functions currently being executed. When a function is called, it is placed on the stack. When it finishes, it is removed.

Consider this example:

function first() {
  console.log("First function");
}

function second() {
  console.log("Second function");
}

first();
second();

The output is:

First function
Second function

These functions execute synchronously, in the order they are called. JavaScript cannot move on to the next statement until the current synchronous work has completed.

If a function performs a very large calculation, it can occupy the JavaScript thread and prevent other callbacks from running until that calculation finishes.

2. Asynchronous Operations

An asynchronous operation allows certain work to proceed without requiring JavaScript to wait synchronously for its completion.

For example, Node.js can initiate a file-reading operation and execute other JavaScript code while the file operation is pending.

const fs = require("node:fs");

fs.readFile("example.txt", "utf8", (error, data) => {
  if (error) {
    console.error("Unable to read file:", error.message);
    return;
  }

  console.log(data);
});

console.log("File-reading operation started");

The message File-reading operation started will normally appear before the file contents because the file-reading callback runs after the asynchronous operation completes.

The precise timing of callbacks depends on the operation and runtime conditions. Asynchronous does not mean that the callback executes immediately or simultaneously with the current JavaScript code.

3. The Role of libuv

Node.js uses a library called libuv to support its event loop and many asynchronous operations.

Libuv provides mechanisms for event notification, timers, and a thread pool used by certain operations, including some file-system and DNS-related work. Network I/O is commonly handled through operating-system facilities rather than by assigning every network request to a separate thread.

This architecture helps Node.js coordinate I/O without requiring a dedicated JavaScript thread for every request.

The event loop, call stack, runtime APIs, and asynchronous operation mechanisms work together. They should not be treated as three separate callback queues that handle every task in exactly the same way.

Understanding the Phases of the Node.js Event Loop

The event loop runs through several phases, each responsible for particular types of callbacks. The main phases commonly described in Node.js documentation are timers, pending callbacks, idle and prepare, poll, check, and close callbacks.

1. Timers Phase

The timers phase executes eligible callbacks scheduled by functions such as setTimeout() and setInterval().

For example:

setTimeout(() => {
  console.log("Timer callback");
}, 1000);

console.log("Program started");

The output begins with:

Program started

The timer callback runs after its delay has elapsed and when the event loop reaches an appropriate opportunity to execute it.

A delay of 1,000 milliseconds is not a guarantee that the callback will execute at exactly one second. Other work and runtime scheduling can delay execution.

2. Pending Callbacks Phase

This phase handles certain I/O-related callbacks deferred from previous event loop iterations.

Not every asynchronous callback runs in this phase. The callback’s type and the operation that produced it determine how it is scheduled.

3. Idle and Prepare Phase

These phases are primarily used internally by Node.js and libuv to prepare for the next event loop iteration.

Application developers generally do not schedule ordinary JavaScript callbacks directly into these phases.

4. Poll Phase

The poll phase is an important part of the event loop. It processes many I/O-related callbacks and may wait for new I/O events when appropriate.

For example, a network response or the completion of an asynchronous file-related operation may result in a callback being executed as part of event loop processing.

If callbacks are ready, Node.js processes the relevant work. If no callbacks are ready, the loop may wait for I/O or move toward another phase, depending on timers and other pending work.

5. Check Phase

The check phase executes callbacks scheduled using setImmediate().

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

console.log("Synchronous statement");

The synchronous statement runs first. The setImmediate() callback runs later during event loop processing.

When comparing setTimeout(callback, 0) and setImmediate(callback) at the top level, their relative order is not universally guaranteed. Their execution order depends on the surrounding context and runtime conditions.

6. Close Callbacks Phase

The close callbacks phase handles certain resource-closing events. For example, a socket may emit a close event when its connection is closed.

Understanding these phases helps developers reason about callback scheduling, but most applications do not need to manage the phases directly.

Callbacks, Promises, and Microtasks in Node.js

Node.js supports several ways to handle asynchronous operations. Callbacks, promises, and async/await are common approaches.

Callbacks in Node.js

A callback is a function passed to another function so that it can be called later.

function greetUser(name, callback) {
  console.log(`Hello, ${name}`);
  callback();
}

greetUser("Developer", () => {
  console.log("Welcome to Node.js");
});

Callbacks are often used with event-driven APIs and traditional Node.js asynchronous methods.

When handling errors in callback-based APIs, Node.js commonly uses the error-first callback pattern, in which the first argument contains an error when an operation fails.

Promises and Microtasks

Promises provide another way to represent the eventual completion or failure of an operation. Their .then(), .catch(), and .finally() handlers make asynchronous workflows easier to organize.

console.log("Start");

Promise.resolve().then(() => {
  console.log("Promise callback");
});

console.log("End");

Output:

Start
End
Promise callback

The promise handler runs after the current synchronous JavaScript execution completes.

Promise handlers are associated with the microtask queue. Node.js also provides process.nextTick(), which uses a separate next-tick queue. Its callbacks are generally processed before the event loop proceeds to the next phase, subject to runtime scheduling details.

Overusing process.nextTick() or continuously scheduling microtasks can delay other event loop work. Developers should avoid creating endless chains of callbacks that prevent I/O and other tasks from progressing.

Using Async and Await

The async and await keywords provide a more readable way to work with promises.

async function getUser() {
  try {
    const user = await fetchUserFromDatabase();
    console.log(user);
  } catch (error) {
    console.error("Unable to retrieve user:", error.message);
  }
}

In this example, fetchUserFromDatabase() represents an asynchronous function that returns a promise. The example illustrates the pattern rather than a complete database implementation.

Using await pauses the execution of that async function until the promise settles. It does not block the entire Node.js event loop while a typical asynchronous operation is pending.

Practical Example: Observing the Node.js Event Loop

A small example can help you see how synchronous statements, promises, timers, and immediate callbacks behave.

Create a file named event-loop.js and add the following code:

console.log("1. Synchronous start");

setTimeout(() => {
  console.log("4. Timer callback");
}, 0);

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

Promise.resolve().then(() => {
  console.log("3. Promise callback");
});

console.log("2. Synchronous end");

The first two messages will appear in this order:

1. Synchronous start
2. Synchronous end

The promise callback normally runs after the current synchronous code completes, before the event loop continues with later phases.

The relative order of the timer and immediate callbacks in this top-level example should not be assumed to be fixed across all execution contexts and runtime conditions.

How to Run the Example

1. Install Node.js if it is not already available on your computer.

2. Save the code as event-loop.js.

3. Open a terminal in the folder containing the file.

4. Run node event-loop.js.

5. Observe the output and repeat the test to explore the scheduling behavior.

Try adding more promise handlers, timers, and synchronous statements. Notice how synchronous work completes before queued asynchronous callbacks can run.

Practical experimentation is a useful way to build an accurate understanding of the event loop.

Common Event Loop Mistakes and Performance Optimization

A strong understanding of the event loop helps developers prevent performance problems. Even though Node.js supports asynchronous I/O, poorly designed JavaScript can still make an application slow or unresponsive.

1. Blocking the Event Loop

CPU-intensive synchronous work can prevent Node.js from processing other callbacks.

For example:

function heavyCalculation() {
  let result = 0;

  for (let i = 0; i < 1_000_000_000; i++) {
    result += i;
  }

  return result;
}

console.log(heavyCalculation());

The loop runs synchronously and can occupy the JavaScript thread for a significant period. During that time, other callbacks scheduled on that thread must wait.

For CPU-heavy work, consider worker threads, separate processes, or a dedicated background-processing service, depending on the task.

2. Assuming Every Async Function Runs in Parallel

Asynchronous code does not automatically make CPU-intensive JavaScript execute in parallel. Many asynchronous operations are scheduled through runtime facilities, and their actual execution model depends on the operation.

Use asynchronous APIs for I/O where appropriate, and use worker threads or other parallel-processing approaches when CPU-intensive tasks need to run independently.

3. Ignoring Errors

An asynchronous operation can fail after the original function has returned. Handle callback errors and rejected promises appropriately.

For example:

async function loadData() {
  try {
    const response = await fetch("https://example.com/api/data");

    if (!response.ok) {
      throw new Error(`Request failed: ${response.status}`);
    }

    return await response.json();
  } catch (error) {
    console.error("Unable to load data:", error.message);
    throw error;
  }
}

This example uses the built-in fetch() API available in modern Node.js versions. The caller should handle the rethrown error if it needs to prevent an unhandled rejection.

4. Monitoring Event Loop Performance

When an application becomes slow, developers should investigate whether the cause is CPU-heavy JavaScript, slow external services, database latency, memory pressure, or another bottleneck.

Useful approaches include:

• Measuring request response times and throughput.

• Profiling CPU usage.

• Monitoring memory consumption.

• Investigating slow database queries and external API calls.

• Using Node.js diagnostic tools to examine event loop delay and utilization.

• Keeping synchronous work in request handlers short.

Optimization should be based on measurements rather than assumptions. Improving the event loop alone will not solve every performance issue.

Applications and Career Relevance of Node.js Event Loop Knowledge

The event loop is relevant to many applications built with Node.js, particularly those that perform frequent I/O operations.

Real-Time Applications

Chat applications, notification services, collaborative tools, and WebSocket-based systems often maintain many active connections. Efficient asynchronous handling helps these systems process incoming messages and other events.

REST APIs and Web Applications

Node.js is commonly used to develop APIs that communicate with databases, third-party services, and front-end applications. Understanding asynchronous execution helps developers avoid blocking request handlers and manage errors correctly.

Streaming and Network Services

Applications that stream data or handle network communication can benefit from non-blocking I/O, provided that data processing and resource management are implemented carefully.

Skills for Node.js Developers

Developers who want to work effectively with Node.js should build knowledge of:

• JavaScript fundamentals and asynchronous programming.

• Callbacks, promises, and async/await.

• HTTP, REST APIs, and error handling.

• Database operations and connection management.

• Performance profiling and debugging.

• Application security and testing.

These skills can support work in back-end development and full-stack development. Career opportunities depend on practical ability, project experience, location, and employer requirements.

Frequently Asked Questions

1. What is the Node.js event loop?

The Node.js event loop is a mechanism that coordinates JavaScript execution and asynchronous callbacks. It enables Node.js to process many I/O-related tasks without requiring JavaScript to wait synchronously for each operation to finish.

2. What are the main phases of the Node.js event loop?

The main phases are timers, pending callbacks, idle and prepare, poll, check, and close callbacks. Each phase handles particular types of work during an event loop iteration.

3. What is the difference between setTimeout() and setImmediate()?

setTimeout() schedules a callback to run after a specified minimum delay, while setImmediate() schedules a callback for the check phase. Their relative execution order can depend on the context in which they are scheduled.

4. Does async/await block the Node.js event loop?

No. When an async function awaits a typical pending promise, that function pauses while other JavaScript work can continue. However, CPU-intensive synchronous code inside an async function can still block the event loop.

5. How can developers prevent event loop blocking?

Keep synchronous work short, use asynchronous I/O APIs, avoid expensive computations in request handlers, and consider worker threads or separate processes for CPU-intensive tasks. Profiling and monitoring can help identify the actual cause of delays.

6. Why should beginners learn the Node.js event loop?

Understanding the event loop helps beginners reason about asynchronous code, handle errors, build responsive APIs, and troubleshoot performance issues. It also provides a foundation for working with more advanced Node.js applications.

Build Your Node.js Skills with Practical Learning

Understanding the Node.js event loop is an important step toward building responsive and efficient JavaScript applications. By learning how the call stack, asynchronous operations, event loop phases, promises, and timers work together, developers can write more reliable code and investigate performance problems with greater confidence.

Continue practising with small programs, API development, database operations, and debugging exercises to strengthen your skills.

Visit eLearning Solutions to explore technology training options and continue developing your software development knowledge.