How Node.js Handles Multiple Requests with a Single Thread

Up until now you must be aware of what Node.js is, and if you are not fully aware if its a library, a framework, or a runtime environment then you need to have a glance at this blog first before continuing this one.

---

Node.js often feels like a miracle when you actually know that it is running on a single thread. You might find it fascinating that even though it is running on a single thread the application built in node does not freeze when two users click a button. Ideally if two users click a button then one of the user needs to be stopped before the task for the other one is complete.

Well there is a technical way to understand this, but in this blog, we would take the chill pill way. We would be understanding the magic through a hotel restaurant.

Process vs. Thread

Now this blog does not cover the technical aspect of how a process is different from thread but we would be understanding in layman terms.

Consider that Process is a restaurant building. It has it's own memory, resources and security.

Thread on the other hand in the waiter working inside the restaurant (Process).

Now in traditional environments like PHP and Java, our restaurant (Process) had many waiters (Threads). Consider it to a five star restaurant (memory intensive), every guest in this restaurant has his own waiter attending to it. So if there are 50 guests, voila you have 50 waiters at your service.

Now our protagonist i.e. Node.js has only one waiter (the Main thread).

Async Operations in Node.js

In the above section we saw that the node.js has a single waiter working at the restaurant, now this waiter works with the kitchen staff( background system) to take orders from every customer that is present.

1. The request: The client makes a request for a pizza, this pizza would take nearly 15 mins to be ready.

2. Non Blocking Move: The waiter takes the order from the client and provides it to the kitchen staff, and instead of waiting outside the kitchen for the order to complete, the waiter goes to the next customer to take their order.

3. The callback: When the pizza is ready, the kitchen staff rings the bells for the waiter to pick up, the waiter does not rush in between, it completes the order it is taking for a customer and once it is free then picks up the pizza and delivers it.

Event Loop (The secret ingridient)

The Event Loop is the mechanism that allows the single thread to delegate tasks and handle multiple client requests. It follows a simple cycle:

• Execute synchronous code (the easy stuff like writing down the order of customer as they say).

• Delegate heavy lifting (Database queries, File reading, API calls) to the system's "Worker Pool" (Libuv). e.g. : take the customer's order and not worry about how it should be cooked and leaving it on the kitchen staff to take care of it

• Wait for the bell to ring (the Callback).

• Resume and send the result back to the user. (Pick up the prepared item when the waiter is free and bring it to the user)

Concurrency vs. Parallelism

It is vital to remember that Node.js is about concurrency, not parallelism.

• Parallelism: Two people running a race at the exact same time on two tracks.

• Concurrency: One person juggling three balls. Only one ball is in their hand at a time, but all three stay in the air.

Why Node.js Scales So Well

When you imaging Node.js to be running on a single thread, the first impression is that it's going to be slow, how is it going to handle multiple requests that occur in parallel, but this is where Node.js acts smart, it does not concern itself with doing parallel jobs, it is more into being a concurrent handler, and doing it fast and at a larger scale.

Node.js has three major parts which help it achieve that:

1. V8 Engine

2. Node Bindings

3. libuv

V8 Engine gives the JIT (just in time compilation) for JS which converts it to machine code efficiently and this helps to make synchronous taks super easy to handle. It manages the call stack.

for (let i = 0; i < 3; i++) {
  console.log("Fast execution", i);
}

The above code block runs instantly because V8 compiles it efficiently

Now libuv is the one which takes care of tasks that take time and handle it efficiently with the Operating system, this releases the thread of doing heavy tasks making it light and ready for taking other tasks.

const fs = require("fs");

console.log("Start");

fs.readFile("bigfile.txt", "utf-8", () => {
  console.log("File done");
});

console.log("End");

Libuv takes care of the file handling here and gets it out of the main thread.

Node bindings helps the V8 engine and libuv to communicate with each other efficiently. It is written in CPP and provides great speed. It allow Node.js to use system-level features.

const fs = require("fs");

fs.readFile("file.txt", "utf-8", (err, data) => {
  console.log(data);
});

JS calls → bindings → native system → result back to JS

Together they make the single threaded Node.js faster and easily scalable.

Comparison Table

Feature	Traditional Multi-Threaded	Node.js Single-Threaded
Memory Usage	High (Every thread costs ~1MB-2MB)	Low (Single thread, minimal overhead)
Context Switching	Expensive (CPU swaps between threads)	Minimal (Always on the same thread)
Best For	Heavy CPU calculation (Video encoding)	I/O intensive tasks (Chat apps, Streaming)

Conclusion

Node.js isn't actually "doing" the hard work alone.

Node.js scales beautifully because most web requests are just "waiting" tasks—waiting for a database, waiting for an API, or waiting for a file. By turning these into asynchronous background tasks, a single thread can handle thousands of concurrent users.