When I first started learning Node.js, one thing confused me more than anything else: why does almost everything seem to be asynchronous?

Coming from languages where code executes one line after another, it felt strange that a function could start running and then continue executing the remaining code without waiting for the previous task to finish. Once I understood why Node.js works this way, callbacks and promises became much easier to understand.

In this article, we'll explore why asynchronous programming exists in Node.js, how callbacks solve the problem, why callbacks eventually become difficult to manage, and how promises provide a cleaner solution.

Why Does Async Code Exist in Node.js?

Node.js is built on a single-threaded event-driven architecture. That means JavaScript executes on one main thread instead of creating a new thread for every request.

Imagine a web server handling thousands of users simultaneously. If Node.js waited for every file read, database query, or API request to complete before moving to the next task, the entire server would become slow because every operation would block the main thread.

Instead, Node.js delegates slow operations such as:

Reading files
Database queries
HTTP requests
Timers
DNS lookups

to the operating system or background workers. While those operations are running, the JavaScript thread continues executing other code.

Once the operation finishes, Node.js places the callback into the Event Loop, where it gets executed when the main thread becomes available.

This design allows Node.js to handle thousands of concurrent connections efficiently without creating thousands of threads.

A Simple File Reading Example

Suppose we have a file called message.txt.

Its content is:

Hello from Node.js!

Now let's read it.

const fs = require("fs");

console.log("Reading file...");

fs.readFile("message.txt", "utf8", (err, data) => {
    if (err) {
        console.log(err);
        return;
    }

    console.log(data);
});

console.log("Program continues...");

Output

Reading file...
Program continues...
Hello from Node.js!

At first this output looks strange.

Why wasn't the file printed immediately?

The reason is that readFile() is asynchronous.

Node.js starts reading the file in the background and immediately continues executing the next line of code.

When the file has been read successfully, Node.js executes the callback function.

Understanding the Callback Flow

Let's see exactly what happens behind the scenes.

Step 1

Node.js starts executing the program.

Start Program

↓

Step 2

The file read request is sent to the operating system.

readFile()

↓

Step 3

Node.js does not wait.

Instead it immediately executes the remaining code.

console.log("Program continues")

↓

Step 4

Once the operating system finishes reading the file, Node.js places the callback into the Event Loop queue.

↓

Step 5

When the JavaScript thread becomes free, the callback executes.

console.log(data)

Callback Execution Diagram

Program Starts
       │
       ▼
 readFile()
       │
       ├───────────────► File is read in background
       │
       ▼
Continue executing code
       │
       ▼
Program waits for Event Loop
       │
       ▼
Callback executes
       │
       ▼
Print file contents

What Are Callbacks?

A callback is simply a function passed into another function that executes later.

Example:

function greet(name, callback) {
    console.log("Hello", name);

    callback();
}

greet("Pandit", () => {
    console.log("Welcome!");
});

Output

Hello Pandit
Welcome!

In asynchronous programming, callbacks are used because Node.js doesn't know when an operation will finish.

Instead of returning the result immediately, it says:

"When the work is done, call this function."

Problems with Nested Callbacks

Callbacks work well for simple tasks.

The problem starts when multiple asynchronous operations depend on each other.

Imagine we need to:

Read a file
Fetch user information
Save the result
Send an email

Using callbacks:

readFile(file, (err, data) => {

    fetchUser(data, (err, user) => {

        saveUser(user, (err) => {

            sendEmail(user, (err) => {

                console.log("Done");

            });

        });

    });

});

Notice how every function becomes nested inside another.

As the project grows:

Indentation increases
Error handling becomes repetitive
Debugging becomes difficult
Reading the code becomes frustrating

This problem is commonly called Callback Hell or the Pyramid of Doom.

Callback Hell Diagram

readFile()
   │
   ▼
fetchUser()
     │
     ▼
 saveUser()
        │
        ▼
 sendEmail()
           │
           ▼
        Finished

As more operations are added, the code keeps moving further to the right.

Introducing Promises

Promises were introduced to solve the readability issues created by callbacks.

A Promise represents a value that may be available:

now
later
or never

Instead of passing callbacks everywhere, asynchronous functions return Promise objects.

Reading a File Using Promises

const fs = require("fs/promises");

fs.readFile("message.txt", "utf8")
    .then((data) => {
        console.log(data);
    })
    .catch((err) => {
        console.log(err);
    });

This version is much cleaner.

Instead of nesting callbacks, we simply tell JavaScript:

If successful, run .then()
If something fails, run .catch()

Promise Lifecycle

Every Promise moves through three possible states.

             Promise Created
                    │
        ┌───────────┴───────────┐
        │                       │
        ▼                       ▼
   Fulfilled               Rejected
(Result Available)          (Error)

Initially every Promise is Pending.

Eventually it becomes either:

Fulfilled
Rejected

Once settled, its state never changes.

Chaining Promises

One of the biggest advantages of promises is chaining.

Instead of nesting functions, we connect them together.

readFile()
    .then(fetchUser)
    .then(saveUser)
    .then(sendEmail)
    .then(() => {
        console.log("Done");
    })
    .catch((err) => {
        console.log(err);
    });

This is much easier to read because every step appears in order.

Callback vs Promise

Callback Version

login((user) => {

    getProfile(user, (profile) => {

        getPosts(profile, (posts) => {

            console.log(posts);

        });

    });

});

Promise Version

login()
    .then(getProfile)
    .then(getPosts)
    .then(console.log)
    .catch(console.error);

The promise version clearly shows the flow from one step to the next without excessive indentation.

Benefits of Promises

Promises solve many of the problems associated with callbacks.

First, they improve readability because asynchronous operations can be written in a linear sequence rather than deeply nested blocks.

They also centralize error handling. Instead of checking for errors after every callback, a single .catch() can handle failures from the entire chain.

Promises are easier to debug, compose, and maintain, especially in larger applications where multiple asynchronous tasks must run one after another.

Perhaps their greatest advantage is that they form the foundation for async/await, which makes asynchronous JavaScript look almost identical to synchronous code.

Real-World Examples of Async Code

Asynchronous programming appears everywhere in Node.js applications.

When a user uploads an image, the server reads the file without blocking other users.

When a REST API requests data from a database, the server continues processing incoming requests while waiting for the database response.

Similarly, calling external APIs, sending emails, generating reports, or downloading files all rely on asynchronous execution to keep applications fast and responsive.

Without asynchronous programming, every user would have to wait for the previous user's request to complete before the server could continue.

Conclusion

Asynchronous programming is one of the core concepts that makes Node.js so powerful. Instead of blocking the main thread while waiting for slow operations, Node.js continues executing other work and processes completed tasks through the Event Loop.

Callbacks were the original way to handle asynchronous operations, but they often led to deeply nested code that was difficult to read and maintain. Promises solved this issue by providing a cleaner, more organized approach with better error handling and easier chaining.

Today, understanding callbacks and promises is essential because they form the foundation of modern JavaScript development. Once these concepts become clear, technologies such as async/await, Express.js, database drivers, and API integrations become much easier to learn and use.

Mastering asynchronous programming is an important step toward becoming a confident Node.js developer.

Async Code in Node.js: Understanding Callbacks and Promises