How does async/await work in JavaScript?

async/await is syntactic sugar over Promises that lets you write asynchronous code in a sequential, top-to-bottom style. Under the hood it still uses Promises, but the resulting code is significantly easier to read, write, and reason about.

Before async/await, handling multiple dependent async operations meant chaining .then() calls. While functional, deeply nested chains became difficult to follow. async/await flattens this into code that reads like synchronous logic.

Consider fetching a user and then fetching their orders — two dependent async calls.

function getUserOrders(userId: string) {
  return fetchUser(userId)
    .then(user => fetchOrders(user.id))
    .then(orders => console.log(orders))
    .catch(err => console.error(err));
}

async function getUserOrders(userId: string) {
  try {
    const user = await fetchUser(userId);
    const orders = await fetchOrders(user.id);
    console.log(orders);
  } catch (err) {
    console.error(err);
  }
}

Placing async before a function declaration does two things:

await pauses execution of the enclosing async function until the awaited Promise settles. It then unwraps the resolved value and returns it.

With raw Promises you chain .catch(). With async/await you use try...catch — the same pattern you already know from synchronous code. This makes error handling consistent and predictable.

async function loadData() {
  try {
    const response = await fetch('/api/data');
    if (!response.ok) throw new Error(`HTTP ${response.status}`);
    return await response.json();
  } catch (error) {
    console.error('Failed to load data:', error);
    throw error; // re-throw if caller needs to handle it
  }
}

// ❌ Slow — sequential (5 seconds for 5 users)
for (const id of userIds) {
  const user = await fetchUser(id);
  results.push(user);
}

// ✅ Fast — parallel (≈1 second for 5 users)
const results = await Promise.all(
  userIds.map(id => fetchUser(id))
);

Nearly every frontend app fetches data from APIs. Interviewers use this question to gauge whether you understand JavaScript's async execution model, can handle errors gracefully, and know when to run operations sequentially vs in parallel. Demonstrating awareness of common pitfalls signals you can write reliable, performant async code in production.