Advertise with Us|Sign Up to the Newsletter

Hi ,

Welcome to WebDevPro #102!

Have you ever squinted at a sideways-scrolling wall of callbacks and thought, “How did my tidy weekend project turn into a bowl of asynchronous spaghetti?” You’re not the only one. Every Node developer has faced the pyramid of doom at some point: those layers of nested anonymous functions that turn stack traces into choose-your-own-adventure chaos. Grab a coffee (or a chamomile, no judgment) and let’s start untangling.

That kind of code used to feel inevitable. In the early 2010s, callbacks ruled the async landscape. But Node has evolved. Today, we’ve got promises, async/await, fetch built-in, and even cancellation with AbortController. Node 22 adds more to the mix with Array.fromAsync, watch-mode, and a faster AbortSignal.

In this piece, I’ll walk you through ways to write asynchronous code that’s readable, predictable, and efficient, from using early returns and named helpers to managing concurrency with queues.

These techniques are rooted in Node.js Design Patterns by Luciano Mammino and Mario Casciaro. And while the book releases in September 2025, you can preorder it now from Packt or Amazon. Many of the ideas in this article are drawn directly from its pages.

Before we jump in and untangle the mess, let’s take a quick look at last week’s standout reads:

Advertise with us
Interested in reaching our audience? Reply to this email or write to kinnaric@packt.com.
Learn more about our sponsorship opportunities here.

Callback hell occurs when code becomes deeply nested with callbacks, making even simple routines hard to read and maintain. For example:

asyncFoo(err => {
asyncBar(err => {
asyncFooBar(err => {
// ...
});
});
});

This so-called "pyramid of doom" results in:

Even a seemingly simple web spider, downloading a URL and saving it to disk, can quickly become a tangle of callbacks:

export function spider(url, cb) {
const filename = urlToFilename(url);
exists(filename, (err, alreadyExists) => {
if (err) { cb(err); }
else if (alreadyExists) { cb(null, filename, false); }
else {
get(url, (err, content) => {
if (err) { cb(err); }
else {
recursiveMkdir(dirname(filename), err => {
if (err) { cb(err); }
else {
writeFile(filename, content, err => {
if (err) { cb(err); }
else { cb(null, filename, true); }
});
}
});
}
});
}
});
}

It works, but the nesting is overwhelming.

Callback hell often starts small but can escalate quickly. Thankfully, a few simple refactors can help you flatten nesting and improve code clarity. Here are two techniques that make a big difference:

1. Early Return

Handle errors immediately and exit the function early to reduce indentation and improve readability:

if (err) return cb(err);
// ...rest of the code

Always use return after invoking the callback to prevent unintended fall-through.

2. Named Functions and Modularity

Break complex flows into named, reusable functions:

function saveFile(filename, content, cb) {
recursiveMkdir(dirname(filename), err => {
if (err) return cb(err);
writeFile(filename, content, cb);
});
}

function download(url, filename, cb) {
console.log(`Downloading ${url} into ${filename}`);
get(url, (err, content) => {
if (err) return cb(err);
saveFile(filename, content, cb);
});
}

The main spider() function becomes far cleaner:

export function spider(url, cb) {
const filename = urlToFilename(url);
exists(filename, (err, alreadyExists) => {
if (err) return cb(err);
if (alreadyExists) return cb(null, filename, false);
download(url, filename, err => {
if (err) return cb(err);
cb(null, filename, true);
});
});
}

Once your callbacks are cleaned up, the next step is mastering how to organize asynchronous tasks. These four core patterns give you control over when and how async operations are executed.

1. Sequential Execution

Sequential execution means performing tasks one after another. In callbacks, this usually leads to nesting, but with good structure, it remains manageable.

Consider the following pattern:

function task1(cb) { asyncOp(() => task2(cb)); }
function task2(cb) { asyncOp(() => task3(cb)); }
function task3(cb) { asyncOp(cb); }

task1(() => { console.log('All tasks done!'); });

If you need to iterate over a list (e.g., download several URLs in order), you can't hardcode the sequence. You need sequential iteration.

Sequential Iteration Example

To spider all links in a page, recursively, one after the other:

function spiderLinks(currentUrl, body, maxDepth, cb) {
if (maxDepth === 0) return process.nextTick(cb);
const links = getPageLinks(currentUrl, body);
if (links.length === 0) return process.nextTick(cb);

function iterate(index) {
if (index === links.length) return cb();
spider(links[index], maxDepth - 1, err => {
if (err) return cb(err);
iterate(index + 1);
});
}
iterate(0);
}

This is the Sequential Iterator Pattern.

✅ Pattern takeaway: Execute one task at a time, waiting for each to finish before moving on. Ideal for ordered operations or rate-limited APIs.

Webinar alert! Mobile experts from Bitrise and Embrace break down advanced CI/CD tips and real-user insights to help you speed up builds & deliver top-quality apps.

2. Concurrent Execution

If the order doesn't matter, run tasks concurrently for speed. For the web spider, that means starting all link downloads at once and calling back when all are done:

In code terms:

function spiderLinks(currentUrl, body, maxDepth, cb) {
if (maxDepth === 0) return process.nextTick(cb);
const links = getPageLinks(currentUrl, body);
if (links.length === 0) return process.nextTick(cb);

let completed = 0, hasErrors = false;
function done(err) {
if (err && !hasErrors) {
hasErrors = true;
return cb(err);
}
if (++completed === links.length && !hasErrors) cb();
}
for (const link of links) {
spider(link, maxDepth - 1, done);
}
}

✅ Pattern takeaway: Launch all tasks together, track completions, and handle the first error gracefully if needed.

3. Fixing Race Conditions

With concurrency, race conditions can occur: e.g., two spiders for the same URL run in parallel and both try to download.

The solution is simple: use a Set to track URLs in progress.

const spidering = new Set();
function spider(url, nesting, cb) {
if (spidering.has(url)) return process.nextTick(cb);
spidering.add(url);
// ... rest of the logic
}

✅ Pattern takeaway: Use simple in-memory tracking (like a Set) to ensure the same task isn’t started multiple times.

4. Limited Concurrent Execution

Running hundreds of downloads at once will exhaust resources. The pattern is to cap concurrent tasks using a queue.

TaskQueue Implementation

export class TaskQueue {
constructor(concurrency) {
this.concurrency = concurrency;
this.running = 0;
this.queue = [];
}

pushTask(task) {
this.queue.push(task);
process.nextTick(this.next.bind(this));
}

next() {
while (this.running < this.concurrency && this.queue.length > 0) {
const task = this.queue.shift();
task(() => {
this.running--;
process.nextTick(this.next.bind(this));
});
this.running++;
}
}
}

Integration in Spider

The spider now pushes crawl tasks to the TaskQueue. The queue manages scheduling, ensuring that no more than N downloads are active.

function spiderTask(url, maxDepth, queue, cb) {
// ... file check, download logic ...
spiderLinks(url, content, maxDepth, queue);
cb();
}

function spiderLinks(currentUrl, body, maxDepth, queue) {
if (maxDepth === 0) return;
const links = getPageLinks(currentUrl, body);
for (const link of links) {
spider(link, maxDepth - 1, queue);
}
}

const spidering = new Set();
export function spider(url, maxDepth, queue) {
if (spidering.has(url)) return;
spidering.add(url);
queue.pushTask(done => spiderTask(url, maxDepth, queue, done));
}

Set up and run:

const url = process.argv[2];
const maxDepth = Number.parseInt(process.argv[3], 10) || 1;
const concurrency = Number.parseInt(process.argv[4], 10) || 2;
const spiderQueue = new TaskQueue(concurrency);

spider(url, maxDepth, spiderQueue);

✅ Pattern takeaway: This approach balances performance and resource usage, ensuring you don’t overload the system while still getting the speed boost of parallelism.

Asynchronous code in Node.js doesn't have to be messy. With a few core principles like early returns, modular functions, and clear control flow patterns, you can escape callback hell and build code that's easier to read, maintain, and scale.

Whether you're running tasks in sequence, firing them off in parallel, or limiting concurrency with a task queue, each pattern gives you more structure and predictability in your async workflows.

✅ Your Sprint Challenge:
Pick one pattern, such as early return, sequential iteration, or limited concurrency, and refactor a small async task in your current project. Even a tiny improvement can make a big difference in how your code reads and behaves.

These patterns are just the beginning.

If you're ready to level up your async thinking, check out and pre-order the updated edition of Node.js Design Patterns by Luciano Mammino and Mario Casciaro.

It's full of actionable ideas for building better backend systems with Node!

Cheers!

Editor-in-chief,

Kinnari Chohan