Introduction

Yes, you can run async.waterfall inside async.series. The key is to remember that series expects each task to finish by calling its callback, so if one series step contains a waterfall, the final waterfall callback must call the surrounding series callback.

This pattern is useful when one stage of a larger workflow has several dependent sub-steps. The waterfall handles the internal dependency chain, and the series call controls the outer sequence of major stages.

What The Two Helpers Do

In the async library for Node.js:

• 'async.series runs tasks one after another and collects their final results'
• 'async.waterfall runs tasks one after another while passing results from one task into the next'

That means they solve different problems. Series is about overall ordering. Waterfall is about dependency between sequential subtasks.

Putting A Waterfall Inside A Series Step

Here is the standard callback-based pattern:

1const async = require("async");
2
3async.series([
4  function stepOne(done) {
5    console.log("step one");
6    done(null, "one complete");
7  },
8  function stepTwo(done) {
9    async.waterfall([
10      function first(next) {
11        next(null, 5);
12      },
13      function second(value, next) {
14        next(null, value * 2);
15      },
16      function third(value, next) {
17        next(null, `waterfall result: ${value}`);
18      }
19    ], function (err, result) {
20      done(err, result);
21    });
22  },
23  function stepThree(done) {
24    console.log("step three");
25    done(null, "three complete");
26  }
27], function (err, results) {
28  if (err) {
29    return console.error(err);
30  }
31
32  console.log(results);
33});

The critical line is done(err, result) inside the final waterfall callback. Without that, async.series never learns that step two has finished.

Why This Pattern Is Useful

Suppose your application does three major things:

• validate input
• perform a multi-step dependent database workflow
• send a final notification

The middle stage might naturally be a waterfall because each query depends on the last query's result. But those three major stages still belong in a larger series. Nesting is reasonable when the two levels express different kinds of sequencing.

Error Propagation

One benefit of both helpers is their error handling model. If any step in the inner waterfall passes an error, the waterfall stops and forwards the error to the series callback. Then async.series stops as well.

That means you do not need extra manual branching for the usual failure path.

1async.waterfall([
2  function first(next) {
3    next(new Error("database unavailable"));
4  },
5  function second(value, next) {
6    next(null, value);
7  }
8], function (err, result) {
9  done(err, result);
10});

Because the first step fails, the second never runs.

Keep Nesting Under Control

Although this works, too much nesting makes callback-based code hard to read. If your flow has many layers of series, waterfall, parallel, and queues, it may be a sign that the code wants named helper functions or a move to async and await.

A modern rewrite is often clearer:

1async function runWorkflow() {
2  const validation = await validateInput();
3  const record = await loadRecord(validation.id);
4  const saved = await updateRecord(record);
5  await sendNotification(saved);
6  return saved;
7}

That does not mean the async library is wrong. It just means its control-flow helpers solve problems that modern JavaScript can now express more directly.

When To Keep Using async Library Helpers

The classic helpers are still reasonable when:

• you are maintaining an older callback-based codebase
• you need consistency with the rest of the module
• you are using utilities from the async library already

In that context, a waterfall inside a series is perfectly normal as long as the callbacks are wired correctly.

Common Pitfalls

• Forgetting to call the outer series callback from the final waterfall callback.
• Calling both next and done from the wrong layer.
• Nesting so deeply that the control flow becomes hard to debug.
• Assuming series will automatically receive intermediate waterfall values.
• Mixing callback-style async helpers with promises without a clear boundary.

Summary

• 'async.series controls outer task ordering.'
• 'async.waterfall is useful for inner steps that depend on previous results.'
• A waterfall can live inside a series task as long as the final waterfall callback calls the series callback.
• Errors from the waterfall naturally propagate to the surrounding series.
• For new code, consider whether async and await express the workflow more clearly.