---
title: The Tradeoffs Async/Await Hides From You
description: "The async await tradeoffs are real: colored functions, hidden scheduling, and error propagation that surprises you. A look at what the keyword actually hides."
canonical: https://lukeocodes.dev/async-await-tradeoffs
type: article
locale: en_GB
published: 2026-08-30T00:00:00.000Z
modified: 2026-08-30T00:00:00.000Z
authors:
  - Luke Oliff
section: JavaScript
tags:
  - JavaScript
  - Engineering
  - async
  - promises
  - event loop
  - microtasks
feed: https://lukeocodes.dev/rss.xml
search: https://lukeocodes.dev/search.json?q={query}
schema:
  - "@context": https://schema.org
    "@graph":
      - "@type": WebSite
        "@id": https://lukeocodes.dev/#website
        url: https://lukeocodes.dev
        name: Luke Oliff
        alternateName: lukeocodes
        inLanguage: en
        publisher:
          "@id": https://lukeocodes.dev/authors/luke#person
        description: Personal blog and writing by Luke Oliff — developer relations, voice AI, developer experience.
        potentialAction:
          - "@type": SearchAction
            target:
              "@type": EntryPoint
              urlTemplate: https://lukeocodes.dev/blog/search?q={search_term_string}
            query-input: required name=search_term_string
      - "@type": Person
        "@id": https://lukeocodes.dev/authors/luke#person
        name: Luke Oliff
        url: https://lukeocodes.dev/authors/luke
        description: Engineer and developer relations leader. Writing about developer relations, AI, and the voice industry, from the UK.
        mainEntityOfPage: https://lukeocodes.dev/authors/luke
        givenName: Luke
        familyName: Oliff
        image: https://lukeocodes.dev/authors/luke.jpg
        jobTitle: Engineer and developer relations leader
        sameAs:
          - https://www.linkedin.com/in/lukeocodes
          - https://github.com/lukeocodes
          - https://bsky.app/profile/lukeocodes.dev
          - https://x.com/lukeocodes
          - https://hashnode.com/@lukeocodes
          - https://dev.to/lukeocodes
        knowsAbout:
          - Developer Relations
          - Developer Experience
          - Voice AI
          - Text-to-Speech
          - Answer Engine Optimisation
          - Search Engine Optimisation
          - Open Source
          - Developer Tooling
          - API Design
          - Speech-to-Text
          - Voice Agents
          - Community Building
        knowsLanguage:
          - English
        nationality: British
        alumniOf:
          - "@type": Organization
            name: The Open University
  - "@context": https://schema.org
    "@graph":
      - "@type": Person
        "@id": https://lukeocodes.dev/authors/luke#person
        name: Luke Oliff
        url: https://lukeocodes.dev/authors/luke
        description: Engineer and developer relations leader. Writing about developer relations, AI, and the voice industry, from the UK.
        mainEntityOfPage: https://lukeocodes.dev/authors/luke
        givenName: Luke
        familyName: Oliff
        image: https://lukeocodes.dev/authors/luke.jpg
        jobTitle: Engineer and developer relations leader
        sameAs:
          - https://www.linkedin.com/in/lukeocodes
          - https://github.com/lukeocodes
          - https://bsky.app/profile/lukeocodes.dev
          - https://x.com/lukeocodes
          - https://hashnode.com/@lukeocodes
          - https://dev.to/lukeocodes
        knowsAbout:
          - Developer Relations
          - Developer Experience
          - Voice AI
          - Text-to-Speech
          - Answer Engine Optimisation
          - Search Engine Optimisation
          - Open Source
          - Developer Tooling
          - API Design
          - Speech-to-Text
          - Voice Agents
          - Community Building
        knowsLanguage:
          - English
        nationality: British
        alumniOf:
          - "@type": Organization
            name: The Open University
      - "@type": BlogPosting
        "@id": https://lukeocodes.dev/async-await-tradeoffs#article
        headline: The Tradeoffs Async/Await Hides From You
        alternativeHeadline: The Tradeoffs Async/Await Hides From You
        description: "The async await tradeoffs are real: colored functions, hidden scheduling, and error propagation that surprises you. A look at what the keyword actually hides."
        datePublished: 2026-08-30T00:00:00.000Z
        dateModified: 2026-08-30T00:00:00.000Z
        url: https://lukeocodes.dev/async-await-tradeoffs
        mainEntityOfPage: https://lukeocodes.dev/async-await-tradeoffs
        inLanguage: en
        author:
          - "@id": https://lukeocodes.dev/authors/luke#person
        isPartOf:
          "@id": https://lukeocodes.dev/#website
        keywords: JavaScript, Engineering, async, promises, event loop, microtasks
        articleSection: JavaScript
        about:
          - "@type": SoftwareApplication
            name: JavaScript
        abstract: "async/await makes asynchronous code read like synchronous code, but it hides three tradeoffs: it colors your functions, it inserts scheduling points you cannot see, and it changes how errors propagate. A 2026 Brown University paper shows no two languages even agree on the semantics."
        speakable:
          "@type": SpeakableSpecification
          cssSelector:
            - .post-tldr
            - h1
        image: https://lukeocodes.dev/og.png?h=The+Tradeoffs+Async%2FAwait+Hides+From+You&d=The+async+await+tradeoffs+are+real%3A+colored+functions%2C+hidden+scheduling%2C+and+error+propagation+that+surprises+you.+A+look+at+what+the+keyword+actually+hides.&e=Writing
        wordCount: 588
        timeRequired: PT3M
        publisher:
          "@id": https://lukeocodes.dev/authors/luke#person
      - "@type": BreadcrumbList
        itemListElement:
          - "@type": ListItem
            position: 1
            name: Home
            item: https://lukeocodes.dev
          - "@type": ListItem
            position: 2
            name: Writing
            item: https://lukeocodes.dev/blog
          - "@type": ListItem
            position: 3
            name: The Tradeoffs Async/Await Hides From You
            item: https://lukeocodes.dev/async-await-tradeoffs
      - "@type": FAQPage
        "@id": https://lukeocodes.dev/async-await-tradeoffs#faq
        mainEntity:
          - "@type": Question
            name: What does 'colored functions' mean in the async await tradeoffs?
            acceptedAnswer:
              "@type": Answer
              text: An async function can only be awaited from another async function, so 'async' spreads up the call stack. Sync and async functions are two colors, and you cannot freely call one from the other without changing the caller.
          - "@type": Question
            name: Does await always yield to the event loop?
            acceptedAnswer:
              "@type": Answer
              text: Yes. Awaiting even an already-resolved value schedules the continuation as a microtask, so code after the await runs later than code that follows the call synchronously. That reordering is easy to miss.
---

[Luke Oliff.](/)

- [Blog](/blog)
- [CV](/cv)
- [Uses](/uses)
- [User manual](/user-manual)
- [Living with ADHD](/living-and-working-with-adhd)
- [RSS](/rss.xml)

[Luke Oliff · Writing](/blog)

# The Tradeoffs Async/Await Hides From You

Aug 2026 · [JavaScript](/blog/category/javascript) · 3 min read · [Luke Oliff](/authors/luke)

**TL;DR:** async/await makes asynchronous code read like synchronous code, but it hides three tradeoffs: it colors your functions, it inserts scheduling points you cannot see, and it changes how errors propagate. A 2026 Brown University paper shows no two languages even agree on the semantics.

The async/await tradeoffs are the price of a keyword that makes asynchronous JavaScript read like synchronous JavaScript. It looks like a clean win, and mostly it is, but it hides three things: it colors your functions, it inserts scheduling points you cannot see, and it changes how errors travel. A recent [design-space paper from Brown University](https://cel.cs.brown.edu/paper/a-design-space-exploration-of-aa/) makes the sharpest version of the point: across languages that all spell it `async`/`await`, no two agree on the semantics, and similar-looking programs run differently.

That paper ([discussed on Hacker News](https://news.ycombinator.com/item?id=49626718)) is worth your time. Here is what the abstraction hides in JS specifically.

## Async colors your functions

An `async` function returns a promise, and to get the value out cleanly you `await` it, which only works inside another `async` function. So `async` climbs the call stack. One async leaf turns its callers async, and theirs.

```js
async function load() {
  const res = await fetch('/data');
  return res.json();
}

// This caller must also be async, or handle the promise by hand.
async function render() {
  const data = await load();
}
```

You cannot drop `load()` into an ordinary synchronous function and pretend nothing changed. The two colors do not mix for free. That is why adding one async call to a legacy sync codebase so often turns into a refactor that ripples through a dozen files.

## Await hides scheduling you did not ask for

The keyword makes the code look sequential, so it is easy to forget that every `await` is a yield point. Control goes back to the event loop, and your continuation is queued as a microtask.

```js
async function f() {
  console.log(1);
  await null;      // yields, even though nothing is pending
  console.log(3);
}
f();
console.log(2);
// prints 1, 2, 3
```

`await null` has nothing to wait for, yet `console.log(3)` still runs after `console.log(2)`. The `await` reordered your program. Multiply that across a handful of awaits in a request handler and the execution order stops matching the reading order, which is precisely where timing bugs breed.

## Errors travel differently than they look

Sync errors bubble up the stack until something catches them. A rejected promise does not, unless you actually `await` it or attach a handler.

```js
async function save() {
  throw new Error('boom');
}

save();          // no await: rejection floats off as unhandledRejection
await save();    // now it throws where try/catch can see it
```

Drop the `await` on the first line and the throw does not fail your function. It becomes an unhandled rejection somewhere else, often logged far from the code that caused it. The keyword that made errors look synchronous is the same keyword whose absence makes them vanish. Every missing `await` is a silently swallowed failure waiting to happen.

## So what do you do with this

Not "stop using async/await". It is still the best tool JS has for this. The point is that the syntax sells you an illusion of straight-line code, and the three tradeoffs, function color, hidden scheduling, and error propagation, are always underneath it.

Lint for floating promises so a missing `await` is a build error, not a 2am page. Assume every `await` is a place other code can run, and never assume the value on the other side of one is fresh. Treat "reads like sync" as a convenience, not a promise. The Brown paper's uncomfortable finding is that even the language designers do not agree on what this construct means, so the least you can do is know what your runtime does.

[← Newer: fd 10.5 Is the find Replacement Worth Memorizing](/fd-find-replacement)

[All posts](/blog) →

## Search this site

`GET https://lukeocodes.dev/search.json?q=<words>` returns matching posts as JSON, each with its page URL and its markdown URL. Add `&limit=<1-50>` for more than 10. How it works: [/blog/search](https://lukeocodes.dev/blog/search.md).

```sh
curl "https://lukeocodes.dev/search.json?q=developer+relations"
```

---

© 2026 Luke Oliff. Posts live at the root of this site.

- [GitHub](https://github.com/lukeocodes)
- [LinkedIn](https://www.linkedin.com/in/lukeocodes)
- [X](https://x.com/lukeocodes)
- [Bluesky](https://bsky.app/profile/lukeocodes.dev)
- [Email](mailto:luke@lukeoliff.com)
- [RSS](/rss.xml)

## Cookies

This site sets one analytics cookie, from Google Analytics, and only in a browser that accepts the cookie banner. A client that does not run scripts sets no cookies, so there is nothing to accept or decline here.

[Cookie policy](/cookies)
