async/await is syntactic sugar over Promises — not a different mechanism. Understanding that they compile to the same thing is the whole answer.

They're the same machinery

// async/await
async function getUser() {
  const res = await fetch("/user");
  const data = await res.json();
  return data;
}

// roughly equivalent Promise chain
function getUser() {
  return fetch("/user").then(res => res.json()).then(data => data);
}

An async function always returns a Promise. await unwraps a Promise's resolved value (or throws its rejection).

How the event loop handles them — identically

await x does three things:

1. Pauses the async function and pops it off the call stack (the rest of the function becomes a "continuation").
2. Lets synchronous code after the call site keep running.
3. When x settles, schedules the continuation as a microtask.

So await is, to the event loop, exactly a .then callback — a microtask.

async function f() {
  console.log("before await");
  await null;
  console.log("after await");   // <-- this line is a microtask
}
console.log("start");
f();
console.log("end");
// start, before await, end, after await

What async/await gives you over raw Promises

• Readability — sequential-looking code instead of .then chains.
• try/catch works for async errors (no .catch chains).
• Easier debugging — real stack frames, step-through in devtools.

What raw Promises still do better

• Concurrency — Promise.all / allSettled / race for parallel work. A common bug is awaiting in a loop sequentially when the calls are independent:

``js // slow: sequential for (const id of ids) await fetchItem(id); // fast: parallel await Promise.all(ids.map(fetchItem)); ``

• Fire-and-forget chains, or passing a Promise around without blocking.

Senior framing

The senior answer: they're not competing — async/await is the control flow layer, Promises are the value layer. Use await for readable sequential logic, but drop to Promise.all the moment operations are independent. And know that the event loop sees no difference — every await continuation is just a microtask.