What is the difference between promises and async/await, and how do you handle errors with each?

When you order food online, the app gives you an order ID immediately, even though the food arrives later. That order ID is a promise: a placeholder for a value that will come in the future. It can end in one of two ways: fulfilled (food delivered) or rejected (order cancelled). Until then it is pending.

With plain promises, you write what should happen next using .then() for success and .catch() for failure. With async/await, you write the same steps as if they were normal top-to-bottom code. await means "wait here for this promise, then continue with its value". Under the hood it is still promises. It is not a different mechanism, just easier to read.

The same task written both ways: fetch a user, then their orders.

// With promise chains
function showOrders(userId) {
  return getUser(userId)
    .then((user) => getOrders(user.id))
    .then((orders) => console.log("Orders:", orders.length))
    .catch((err) => console.log("Failed:", err.message))
    .finally(() => console.log("Done"));
}

// With async/await
async function showOrdersAsync(userId) {
  try {
    const user = await getUser(userId);
    const orders = await getOrders(user.id);
    console.log("Orders:", orders.length);
  } catch (err) {
    console.log("Failed:", err.message);
  } finally {
    console.log("Done");
  }
}

Running independent work in parallel:

async function loadDashboard() {
  // Slow: the second request waits for the first.
  // const profile = await getProfile();
  // const offers = await getOffers();

  // Faster: both start together.
  const [profile, offers] = await Promise.all([getProfile(), getOffers()]);
  return { profile, offers };
}

• An async function always returns a promise. Returning a value fulfils it; throwing an error rejects it.
• await pauses only that async function. The rest of the program keeps running; the code after await resumes later as a microtask (see the event loop).
• If the awaited promise rejects, await throws, so a normal try/catch can catch it.
• A .catch() at the end of a chain catches a rejection from any earlier step.

Useful helpers:

Calling APIs, reading files in Node, querying databases, and waiting for a UPI payment status are all asynchronous. Most modern codebases use async/await for readability and use Promise.all or Promise.allSettled when several calls can happen at once.

• Forgetting await, so you get a pending promise instead of the data.
• Awaiting independent calls one after another, which makes the total time the sum of all calls.
• Using await inside forEach. It does not wait. Use for...of or Promise.all with map.
• Leaving a promise without any .catch() or try/catch, which causes unhandled rejections.
• Wrapping a promise in new Promise unnecessarily.

• What is the output order if you mix await, setTimeout and console.log?
• What is the difference between Promise.all and Promise.allSettled?
• Can you use await at the top level of a file?