From callbacks to async/await

A promise is an object representing a value that is not ready yet. It is always in exactly one of three states: pending, fulfilled with a value, or rejected with a reason — and once it leaves pending, it never changes state again.

function wait(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

wait(100).then(() => console.log("done"));

async/await is syntax over the same promises — it does not replace them, it makes them readable.

async function load() {
  const res = await fetch("/api/users/1");
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json();
}

An async function always returns a promise, whatever you return inside it. await pauses that function until the promise settles; it does not pause the rest of the program, which keeps running.

Try it

1function wait(ms) {2  return new Promise((resolve) => setTimeout(resolve, ms));3}4 5let running = 0;6let peak = 0;7 8async function task() {9  running++;10  peak = Math.max(peak, running);11  await wait(20);12  running--;13}14 15export async function run() {16  peak = 0;17  await task();18  await task();19  await task();20  const sequentialPeak = peak;21 22  peak = 0;23  await Promise.all([task(), task(), task()]);24  const parallelPeak = peak;25 26  return { sequentialPeak, parallelPeak };27}

The try/catch that never catches

try {
  sendWelcomeEmail(user.email);   // no await
} catch (err) {
  logger.warn(err);                // never runs
}

try only guards the synchronous part of its block. The call returns a promise immediately, the block finishes, and the rejection arrives later with nothing on the stack to catch it — an unhandled rejection, which under Node's default policy can crash the process.

The fix is await:

try {
  await sendWelcomeEmail(user.email);
} catch (err) {
  logger.warn(err);                 // now it actually runs
}

1async function sendEmail() {2  throw new Error("SMTP down");3}4 5export async function run() {6  const log = [];7 8  try {9    const pending = sendEmail();           // no await10    log.push("try block finished");11    pending.catch((e) => log.push(`only .catch saw: ${e.message}`));12  } catch (e) {13    log.push("catch block ran");           // never14  }15 16  try {17    await sendEmail();18  } catch (e) {19    log.push(`awaited, caught: ${e.message}`);20  }21 22  return log;23}

The habit worth building: every promise is awaited, returned, or explicitly discarded with a comment saying why it is fire-and-forget. A bare promise-returning call sitting on its own line as a statement always deserves a second look.

Sequential awaits waste the wait

const a = await loadUser(id);      // waits
const b = await loadOrders(id);    // then waits again, even though
                                     // loadOrders never needed `a`

If two awaited calls do not depend on each other, awaiting them one after another adds their times together for no reason. Promise.all starts both immediately and waits once:

const [a, b] = await Promise.all([loadUser(id), loadOrders(id)]);

Promise.all rejects as soon as any one promise rejects, and cancels nothing — the others keep running in the background. Promise.allSettled is for when you want every outcome, failures included, rather than the first failure stopping everything.

Common mistakes

• try around a call you did not await. The block finishes before the promise rejects, so the catch never runs — the second example shows it.
• Awaiting independent calls one after another. The waits add up; start them together and await Promise.all(...). The first example counts how many tasks were actually running at once.
• Promise.all when you need every outcome. It rejects on the first failure and the other results are lost to you. Use .