Async patterns

Async work needs traffic rules

async and await make asynchronous code read from top to bottom, but real applications still need patterns. A network can be slow, a server can be busy, a user can leave, and eight jobs can all want the same resource at once.

This lesson collects five patterns you will reuse constantly: retry with backoff, timeouts, queues and pools, polling, and sleep helpers. They all share one rule: waiting should be deliberate, bounded, and cancelable when possible.

If you want to review the building blocks, revisit Promises, Timers, Error handling strategies, and The event loop.

A retry is another attempt after a failure. Backoff means the waits get longer: 100 ms, 200 ms, 400 ms, then perhaps capped at 2 seconds. With full jitter, you pick a random wait between 0 and that cap so every client does not retry at the same instant.

Retry only when both conditions are true: the error is probably temporary, and repeating the operation is safe. Reads are usually safe. Writes need idempotency, such as a payment API accepting an idempotency key so repeated attempts do not charge twice.

1async function retry(operation, options) {2  for (let attempt = 0; attempt < options.maxAttempts; attempt += 1) {3    try {4      return await operation();5    } catch (error) {6      if (!error.temporary) throw error;7      const uncapped = options.baseDelay * 2 ** attempt;8      const delay = Math.min(uncapped, options.maxDelay);9      const wait = options.random() * delay;10      await options.sleep(wait);11    }12  }13  throw new Error("No attempts left");14}

The lab injects a fixed random function and short sleeps. Production code should do the same for tests: inject sleep and random, then assert delays and attempt counts instead of waiting for real time.

A timeout is a promise that rejects after a limit. Promise.race lets the real task and the timer compete. The first one to settle decides the wrapper’s result.

1function withTimeout(promise, ms) {Run2  let timer;3  const timeout = new Promise((_, reject) => {4    timer = setTimeout(() => reject(new Error("Timed out")), ms);5  });6  return Promise.race([promise, timeout])7    .finally(() => clearTimeout(timer));8}

Two details matter. First, clear the timeout in finally so the timer does not fire later or keep a Node process alive. Second, use an AbortController when the underlying task can cooperate. The previous lesson, Cancellation with AbortController, covers that pattern in detail.

A pool keeps at most N tasks in flight. It is the difference between opening 100 network requests at once and allowing four workers to steadily drain a line. This protects the browser, the server, and the user’s battery.

1async function runPool(tasks, concurrency) {2  const results = [];3  let next = 0;4  async function worker() {5    while (next < tasks.length) {6      const index = next++;7      results[index] = await tasks[index]();8    }9  }10  await Promise.all(Array.from({ length: concurrency }, worker));11  return results;12}

Decide the failure policy before you write the helper. Collect errors when independent jobs should all get a chance, such as image thumbnails. Fail fast when one failure makes the whole result useless, such as loading required configuration.

Polling means checking again and again until a job is done, failed, aborted, or timed out. It is useful when the server cannot push updates yet. Later, push tools such as WebSocket or Server-Sent Events can act more like a doorbell.

1async function pollJob(checkStatus, { interval, timeout, signal, sleep }) {2  const deadline = Date.now() + timeout;3  while (Date.now() < deadline) {4    if (signal?.aborted) throw signal.reason;5    const status = await checkStatus();6    if (status.state === "done") return status.value;7    if (status.state === "failed") throw new Error(status.reason);8    await sleep(interval, { signal });9  }10  throw new Error("Polling timed out");11}

Prefer an async loop or nested setTimeout over setInterval for network polling. The loop can await the request and the sleep, so the next poll does not start while the previous one is still running.

JavaScript does not have a built-in browser sleep function, but a timer can resolve a promise. Awaiting that promise pauses only your async function; the page and event loop keep working.

1const sleep = (ms) => new Promise((resolve) => {2  setTimeout(resolve, ms);3});4 5await sleep(500);6console.log("half a second later");

1function sleep(ms, { signal } = {}) {2  return new Promise((resolve, reject) => {3    if (signal?.aborted) return reject(signal.reason);4    const timer = setTimeout(resolve, ms);5    signal?.addEventListener("abort", () => {6      clearTimeout(timer);7      reject(signal.reason);8    }, { once: true });9  });10}

In Node.js, you can also import setTimeout from node:timers/promises and await it directly. In browser lessons, a small helper keeps the idea visible.

Where you’ll use this

Real front-end code often combines patterns. A draft save might retry a safe idempotent PUT, parse the response with a timeout, and stop if the user leaves the page.

1async function saveDraft(draft, api) {2  const result = await retry(3    () => api.putDraft(draft, { idempotencyKey: draft.id }),4    { maxAttempts: 4, baseDelay: 100, maxDelay: 1000, sleep, random: Math.random },5  );6  return withTimeout(result.json(), 2000);7}

Common misconceptions

• “Retry everything.” Retry transient errors only. A 400, 401, or unsafe payment write needs a fix, not another identical attempt.
• “Backoff can run forever.” Always cap delay, attempts, and total time.
• “Promise.race cancels the loser.” It settles the wrapper. The losing task keeps running unless it cooperates with cancellation.
• “setInterval is perfect for polling.” It can overlap slow requests. An async loop waits before the next check.
• “A pool changes result order.” Completion order changes, but you can store each result at its original index.
• “sleep blocks JavaScript.” Awaiting a sleep promise pauses one async function, not the whole event loop.

Key takeaways

• Retry only transient, safe operations; use exponential backoff, jitter, and caps.
• Promise.race is a timeout wrapper, not cancellation. Clear timers and use signals when work must stop.
• Pools keep at most N tasks in flight and should define how failures are handled.
• Polling should be an async loop or nested timeout so checks do not overlap.
• sleep is just a promise around a timer; make it cancellable when it may wait a long time.

Async patterns are reusable waiting shapes that make asynchronous work bounded, polite, and predictable.

Up next: The browser environment.