Debounce async promise resolver

Q: Debounce async promise resolver

**Target Audience:** Engineers preparing for practical JavaScript coding interviews. **Difficulty:** Medium > **How to read this doc:** the "every pending caller resolves, not just the last one" requirement — the part a plain callback-based debounce cannot handle at all — was verified directly: 3 real calls in a burst, all 3 returned promises resolving to the identical final result. ## 1. The problem, restated `debounceAsync(fn, wait)` wraps an async function: only the LAST call in a rapid burst actually triggers a real invocation of `fn`, but EVERY caller in that burst — including ones made before the last — must receive a promise that correctly resolves (or rejects) with that single real outcome. ## 2. Clarifying questions a strong candidate asks | Question | Why it matters | | :--- | :--- | | Every caller resolves, or just the last? | The real, correct contract: every caller resolves — a caller left permanently hanging is a genuine bug (a memory leak / stuck UI state). | | Reje

The problem

Problem, as an interviewer would state it: "Write debounceAsync(fn, wait) — like regular debounce, but fn returns a promise, and EVERY caller (even ones from earlier in the burst) needs to get back a promise that resolves with the eventual, single real result."

Examples:

Code

const search = debounceAsync(fetchResults, 300);
const [r1, r2, r3] = await Promise.all([search("r"), search("re"), search("rea")]);
// only ONE real fetchResults call happens (with "rea"); r1 === r2 === r3

Clarifying questions expected:

Should EVERY caller in the burst resolve, or only the last one (with earlier callers left hanging forever)?
What happens if the eventual real call rejects — do ALL pending callers reject too?
Does this need to interoperate with a plain, non-async debounce, or is it a separate implementation?

Code / implementation expected: Yes — real, direct proof that 3 rapid calls in a burst produce exactly 1 real underlying invocation, with all 3 callers' promises resolving to that identical result.

js-coding
utility
algorithm

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 practical JavaScript coding interviews. Difficulty: Medium

How to read this doc: the "every pending caller resolves, not just the last one" requirement — the part a plain callback-based debounce cannot handle at all — was verified directly: 3 real calls in a burst, all 3 returned promises resolving to the identical final result.

1. The problem, restated

debounceAsync(fn, wait) wraps an async function: only the LAST call in a rapid burst actually triggers a real invocation of fn, but EVERY caller in that burst — including ones made before the last — must receive a promise that correctly resolves (or rejects) with that single real outcome.

2. Clarifying questions a strong candidate asks

Question	Why it matters
Every caller resolves, or just the last?	The real, correct contract: every caller reso

The solution is hidden so you can try first

5 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, direct proof: debounceAsync() makes exactly one real underlying call for a 3-call burst, with all 3 callers resolving to the same result