How does async/await work?

Question

IT Interview Practice · Accepted Answer

`async/await` is **syntax sugar over Promises** that lets you write asynchronous code that reads like synchronous code. An `async` function always returns a Promise; `await` pauses the function until a Promise settles, then resumes with its value.

```js
async function loadUser(id) {
  try {
    const res = await fetch(`/api/users/${id}`); // pause until the response
    const user = await res.json();               // pause until parsed
    return user;                                  // becomes the resolved value
  } catch (err) {
    console.error(err); // catches rejections from any await above
  }
}
```

## Sequential vs parallel — a common performance mistake

`await` runs things **one after another**. If two requests don't depend on each other, awaiting them in sequence is wastefully slow:

```js
// ❌ sequential — total time = a + b
const a = await getA();
const b = await getB();

// ✅ parallel — total time = max(a, b)
const [a, b] = await Promise.all([getA(), getB()]);
```

## Error handling

Use `try/catch` instead of `.catch`. A rejected awaited promise throws, so one `catch` covers the whole block.

## Under the hood

It's still Promises and the microtask queue — `await` doesn't block the thread; it yields control so other code runs, then resumes. Don't forget: calling an `async` function without `await`ing (or `.catch`) it can swallow errors.

## Why it matters

It makes async flows readable and is the modern default for sequencing async work — but you must consciously parallelize independent operations with `Promise.all`.

Sequential vs parallel — a common performance mistake

Error handling

Under the hood

Why it matters

Related questions