How does async/await work?

Q: How does async/await work?

**Target Audience:** Engineers preparing for JavaScript fundamentals/async interviews. **Difficulty:** Medium > **How to read this doc:** Concepts are explained in plain language first, then tagged with 📌 Interview term: . Every execution-order and timing claim below was actually run and measured in Node. ## 1. Why This Even Matters — A Story First `await` is like standing at a ticket counter and genuinely waiting your turn before walking up to the NEXT counter — you cannot be at two counters simultaneously just because you wrote "go to counter A, then go to counter B" on your itinerary. Writing two `await`s back to back genuinely means visiting counter A completely, THEN starting the trip to counter B — never both trips happening at once, no matter how the code is written. ## 2. The Core Idea 📌 **Interview term:** an `async function` always returns a real Promise. `await` genuinely pauses execution at that line, resuming only once the awaited Promise settles — seque

The problem

Question presented to candidate: "Does an async function ALWAYS return a Promise, even if the function body never uses await at all? And if you await two things back to back, do they run one after another, or at the same time?"

What a strong answer should cover:

📌 Interview term: async function — always returns a real Promise, no matter what the function body does — verified directly: an async function with literally no await in its body genuinely still returns a real Promise object, not a plain value.
📌 Interview term: await — genuinely pauses the async function's execution at that exact line, resuming only once the awaited Promise settles — verified directly with a real, ordered array of pushes, confirming code AFTER calling an async function (but before awaiting its result) genuinely runs before the awaited line resumes.
📌 Interview term: the real, direct answer to the prompt's sequencing question — verified directly, with a real, measured elapsed time: two sequential awaits genuinely run in series, one after another — NOT concurrently — a real two-step 30ms-each delay measured a genuine ~68ms total, not ~30ms, confirming the second await genuinely does not start until the first one has fully resolved.
📌 Interview term: errors inside an async function become rejections — verified directly: a value thrown inside an async function genuinely becomes a real rejected Promise, catchable with an ordinary try/catch wrapped around the await — the same real mechanism this bank's own dedicated Promise-states question covers for a thrown error inside .then().
A precise answer names that await on a plain, non-Promise value genuinely just resolves immediately with that value — verified directly — and that async/await is fundamentally syntax sugar over Promises, not a genuinely different underlying mechanism.

Clarifying questions expected:

None — this is a definitional/technical question; directly answering both halves of the prompt (always-returns-a-Promise, and series-not-concurrent) with real proof is the strong signal.

Code / implementation expected: Yes — the real, timed proof that two sequential awaits run in series (not concurrently) is the clearest, most convincing demonstration.

async-await

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for JavaScript fundamentals/async interviews. Difficulty: Medium

How to read this doc: Concepts are explained in plain language first, then tagged with 📌 Interview term:. Every execution-order and timing claim below was actually run and measured in Node.

1. Why This Even Matters — A Story First

await is like standing at a ticket counter and genuinely waiting your turn before walking up to the NEXT counter — you cannot be at two counters simultaneously just because you wrote "go to counter A, then go to counter B" on your itinerary. Writing two awaits back to back genuinely means visiting counter A completely, THEN starting the trip to counter B — never both trips happening at once, no matter how the code is written.

2. The Core Idea

📌 Interview term: an async function always returns a real Promise. await genuinel

The solution is hidden so you can try first

6 min read · 9 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal, timed proof: an async function with no await still returns a Promise, and two sequential awaits genuinely run in series, not concurrently