When you have multiple async operations, the question is how their results and failures combine. The toolbox:

Promise.all — all succeed, or fail fast

Runs them in parallel, resolves with an array of all results — but rejects immediately if any one rejects (the others keep running but you get the first error).

const [user, posts, prefs] = await Promise.all([getUser(), getPosts(), getPrefs()]);

Use when you need all results and any failure means the whole thing fails (loading a page that needs all three).

Promise.allSettled — wait for all, tolerate failures

Runs in parallel, always waits for every promise, resolves with an array of { status, value } / { status, reason } — never rejects.

const results = await Promise.allSettled([getA(), getB(), getC()]);
// results: [{status:"fulfilled", value}, {status:"rejected", reason}, ...]

Use when you want every outcome and partial failure is OK — fetch 10 widgets, render the 8 that succeeded.

Promise.race — first to settle (either way)

Resolves or rejects with the first promise to settle, whether it succeeded or failed.

await Promise.race([fetchData(), timeout(5000)]); // timeout pattern

Use for timeouts or "whichever responds first."

Promise.any — first to succeed

Resolves with the first fulfilled promise; ignores rejections; only rejects (with an AggregateError) if all fail.

await Promise.any([fetchFromMirror1(), fetchFromMirror2()]); // first working mirror

Use for fallbacks / redundancy — first source that works.

Sequential vs parallel

Separate axis: await in a for loop runs them one after another (each waits for the previous) — necessary when each step depends on the last, but slow otherwise. Independent operations should run in parallel (kick them all off, then Promise.all). A classic perf mistake is await-ing in a loop when the iterations are independent.

The decision table

The framing

"It comes down to how results and failures combine. Promise.all — parallel, all-or-nothing, rejects on the first failure. Promise.allSettled — parallel, waits for everything, gives you every outcome and never rejects, for when partial failure is fine. Promise.race — first to settle either way, the timeout pattern. Promise.any — first to succeed, for fallbacks. And separately, sequential await-in-a-loop versus parallel — only go sequential when each step depends on the last; awaiting independent operations in a loop is the classic perf bug."