A plain for...of with await is the clearest way to run async work strictly one after another. Each iteration suspends until the previous promise settles, so the order of out matches the input order regardless of timing. Use this when each step has a side effect that must not interleave (writes, audit logs, rate-limited APIs) or when you simply prefer a readable loop over a functional chain. The trade-off versus Promise.all is wall-clock latency: n items at t ms each take n * t ms instead of t ms.

Folding reduce over the array, starting from Promise.resolve([]), builds a chain where each .then returns the next promise. The accumulator carries both the running result array and the chain itself, so the function returns a single promise that settles once every step has completed in order. The shape is dense but useful when you want to avoid for await (older targets, lint rules) or to keep the call expression-only. Functionally identical to the for...of version in throughput and ordering.

When each step depends on the previous one's output, pipe the steps directly instead of carrying an array. pipeAsync accepts an array of unary async functions and returns a function that threads the input through every step in order. This is the async cousin of synchronous function composition and the right shape for ETL stages, request middleware, or HTTP retries that need to reuse the previous attempt's data. Throw inside any step and the pipeline rejects at that point with the original error stack intact.