How Values Flow Through Time: Rethinking Promise Chaining in JavaScript

At first, Promise chaining looks like a neat trick.

You write:

Promise.resolve(1)
  .then(x => x + 1)
  .then(x => x + 1)
  .then(console.log)

And it prints:

3

It feels like a sequence.

A clean, linear flow.

But underneath that simplicity is a system doing far more than just “calling functions in order.”

A Chain Is Not a Sequence

It’s tempting to think of .then() as:

“Run this, then run that.”

But that’s not quite what’s happening.

Each .then() doesn’t continue the same Promise.

It creates a new one.

Every step is a transformation that produces a new state.

Promise → Promise → Promise → Promise

What looks like a chain is actually a series of handoffs.

The Hidden Contract

Each .then() follows a simple rule:

Whatever you return becomes the input of the next step

This is the entire mechanism.

If you return a value:

.then(x => x + 1)

That value flows forward.

If you return a Promise:

.then(x => Promise.resolve(x + 1))

The chain pauses.

Waits.

And then continues with the resolved result.

And if you return nothing—

.then(x => {
  x + 1
})

Something subtle happens.

The Silent Break

In this case, the function returns undefined.

Not because you said so—

but because you didn’t say anything at all.

And so the chain continues with undefined.

The value didn’t change.

It was simply never passed along.

This is one of the most common places where expectations and reality diverge.

Not Mutation—Transformation

Another subtle point is this:

.then(x => x + 1)

This does not change x.

It creates a new value.

Each step receives a value,

transforms it,

and passes a new one forward.

Nothing is mutated.

Everything is replaced.

The chain is not about modifying data.

It’s about transforming it over time.

Flattening the Unexpected

One of the most powerful aspects of Promise chaining is how it handles nested Promises.

.then(x => Promise.resolve(x + 1))

You might expect this to create a nested structure.

A Promise inside a Promise.

But it doesn’t.

JavaScript unwraps it.

It waits for the inner Promise, then continues as if it were a normal value.

This is not accidental.

It’s part of the resolution process.

Every step ensures that the chain remains flat.

Time Is Part of the System

Another detail that’s easy to miss:

.then() does not run immediately.

It runs in the microtask queue.

This means the chain is not just about values—

it’s about timing.

Each step is scheduled.

Each result is delivered asynchronously.

Even if everything looks synchronous.

Errors Flow Too

Values are not the only thing that travel through the chain.

Errors do as well.

.then(() => {
  throw new Error("fail")
})

This doesn’t break the chain.

It redirects it.

The next .then() is skipped,

and the error moves forward until it is handled.

The chain adapts.

It doesn’t stop.

A Different Way to See It

Promise chaining is often described as a way to handle async code.

But that’s only part of the story.

It’s more accurate to see it as:

A pipeline for transforming values across time

Each step:

• receives a value
• decides what to return
• hands control to the next Promise

And the system ensures everything stays consistent—

whether the value is immediate, delayed, or wrapped in another Promise.

A Final Thought

At a glance, Promise chaining feels like a convenience.

A cleaner way to write asynchronous code.

But underneath, it’s a carefully designed system:

• values are passed, not shared
• results are unwrapped, not nested
• execution is scheduled, not immediate

And once you see that, the chain stops being just syntax—

and becomes a flow.

A flow where what you return determines what comes next.

And where a single missing return can quietly change everything.