Async interview questions

Implement a countdown latch whose wait resolves once countDown has been called the required number of times.

Fetch successive pages with an opaque cursor, accumulating items and tracking whether more remain.

Run async tasks in sequence, feeding each result into the next, stopping the chain on the first rejection.

Implement Promise.race so it settles with the outcome of whichever input promise settles first.

Implement a function that returns a promise resolving after the specified number of milliseconds.

Fetch with a timeout that aborts the request via AbortController and honors an external abort signal.

Build an analytics client that queues tracked events, flushes them in batches, and retries failed sends with backoff.

Implement Array.fromAsync: build a promise of an array from a sync or async iterable, awaiting each value in order.

Build an autocomplete that debounces typing, fetches matching results from an API, and handles loading and stale responses.

Implement an async debounce that resolves only the newest call and discards the results of superseded ones.

Implement an async memoize that caches results by key for a TTL and coalesces concurrent calls for the same key.

Implement an async mutex whose acquire returns a release function, serializing access so only one holder runs at a time.

Implement an async semaphore that admits up to N concurrent holders and queues the rest until a permit frees.

Implement a task queue that runs async jobs under a concurrency limit and resolves an idle promise when drained.

Buffer events and flush them in batches when a size threshold or a max-wait timer is reached.

Wrap a promise so it can be cancelled — the wrapper rejects on cancel and ignores the underlying settlement.

Implement a circuit breaker that trips open after repeated failures, rejects fast while open, then probes half-open.

Cache responses by URL and revalidate with an ETag, reusing cached data on a 304 Not Modified.

Build a schema-driven form validator with composable per-field rules, cross-field checks, and async validators that report all errors.

Build an axios-style client whose request and response interceptors transform each call as it passes through the chain.

Dedupe by idempotency key: run a task at most once per key, cache the result with a TTL, and retry on failure.

Build a long-polling loop that re-issues a held request as each returns, advances a cursor, backs off on error, and stops cleanly.

Implement a function that applies an async mapper to every item in an array and resolves with the results.

Coalesce all schedule calls made in one synchronous frame into a single flush on the next microtask.

Queue writes while offline and flush them in FIFO order when the network returns, retrying failures without dropping or reordering.

Implement pollUntil — call an async function on an interval until a predicate passes or a timeout elapses.

Schedule async requests under a concurrency limit, always running the highest-priority waiter next with a stable FIFO tiebreak.

Implement a function that combines the results of two promises into a single value using a merger function.

Implement a promise pool that runs task factories with a concurrency cap and resolves to their results in order.

Implement a function that races a promise against a timer and rejects if the promise doesn't settle in time.

Implement Promise.all so it resolves with an array of results or rejects on the first rejection.

Implement Promise.any so it resolves with the first fulfilled value or rejects with an AggregateError.

Implement a function that wraps a Node-style error-first callback function so it returns a promise.

Extend promisify so the wrapped function can override the resolved value via a custom override hook.

Wrap a WebSocket so it auto-reconnects with exponential backoff, queues sends while down, and re-emits its events.

Wrap an async call with retries, backoff, and a per-attempt timeout so transient failures recover.

Implement retry — re-run a failing async function with a delay that grows exponentially between attempts.

Implement singleflight so concurrent calls for the same key share one in-flight promise instead of duplicating work.

Return cached data instantly, serving stale values while revalidating them in the background.

Run async tasks in dependency order, executing independent ones in parallel and catching cycles.

Implement a minimal test runner that registers cases, runs each one, and reports pass and fail counts.

Implement a hook that runs an async function and tracks its status, value, and error, with a manual execute trigger.

Implement an async hook that exposes a retry function to re-run the last operation on demand.

Implement a data-fetching hook exposing data, error, and loading, that refetches when the URL changes and ignores stale responses.

Implement a hook that tracks the loading, data, and error states of a promise-returning request.

Implement Node-style async runners — run error-first tasks in parallel or in series and collect their results.

Implement a read-write lock that allows many concurrent readers or one exclusive writer without starving writers.

Run a queue of tasks in time slices, yielding control between them so the main thread stays responsive.

Batch and cache load(key) calls made in one tick into a single batch function call, preserving order.

Build a collapsible tree that lazily loads a node's children the first time it is expanded.

Implement an async map that processes an array with a bounded number of in-flight tasks.

Implement an async middleware composer that chains functions Koa-style, threading a shared context through next.

Build a framework-agnostic query cache with request dedup, staleTime, subscribers, and invalidation.

Implement a minimal Observable with subscribe/unsubscribe and of/from plus map and filter operators.

Apply optimistic updates immediately and roll them back on failure, even with concurrent mutations.

Build a search box that caches results per query and dedupes in-flight requests.

Build a redux-saga-style interpreter that runs a generator of declarative effects and resumes it with each result.

Build a mini reactive-streams library: a cold Observable and pipeable operators composed with a .pipe() chain.

Extend a tiny test runner so it correctly awaits asynchronous specs and asynchronous setup or cleanup hooks.

Implement a hook that loads more pages when a sentinel element scrolls into view, guarding against duplicate loads.

Implement a stale-while-revalidate data hook with an in-memory cache, dedup, and revalidation shared across components.

Implement a WebSocket hook exposing connection status, last message, and send, with auto-reconnect and cleanup.