Practice Prompts

Build GET /users?page=1&limit=20 that is JWT-protected, validates query params, and returns a paginated result. Show the controller, the query DTO, and how the guard/pipe are wired.

Implement a @Roles('admin') decorator and a RolesGuard that reads required roles from route metadata and compares them to request.user.roles. Make method-level roles override class-level.

Write retry(fn, { retries, baseMs }) that retries a failing async function with exponential backoff and jitter, only retrying transient errors, and gives up after N attempts.

Implement an LRU cache with O(1) get and set and a max capacity that evicts the least-recently-used entry.

Process 10,000 items by running an async worker(item) with at most N in flight at once (a bounded Promise.all). Why not just Promise.all(items.map(worker))?

Write an interceptor that wraps every successful response in { data, timestamp } without each handler knowing about it.

Serve a multi-GB file as a gzipped download without loading it into memory, and make sure errors and resources are handled.

Implement a distributed token-bucket limiter (refill rate R, capacity C) that's correct across multiple app instances. Why must it be atomic?

A Post.author field resolver runs one query per post over a list of 50 posts (1+50 queries). Fix it with DataLoader and explain the two classic bugs.

Implement graceful shutdown so a SIGTERM (k8s rollout) drains in-flight requests and closes resources before exit.

Design the backend for a B2B SaaS where each tenant's data must be isolated. Cover the isolation model, tenant resolution, and how you prevent cross-tenant leakage.

An order flows through payment, inventory, and shipping — separate services. Design it for reliability: no double charges, no lost orders, consistent state.

You have a gateway and several backend services. Where do you authenticate and authorize, and how do downstream services trust the caller?

A product-detail endpoint gets 50k RPS, 99% reads, data changes a few times a day. Design the caching so it's fast, fresh enough, and survives a cache miss storm.

Clients retry on timeout, so a “charge card” request can arrive twice. Design the API + storage so a customer is never double-charged.

You're on call for a Nest API and latency just spiked. Design the observability you'd want in place to diagnose it in minutes, not hours.

Reimplement Promise.all(promises): resolve to an array of results in input order, reject as soon as any input rejects (fail-fast), and resolve to [] for an empty array. Don't use the built-in.

Build an EventEmitter with on, off, once, and emit. A once listener fires exactly one time then removes itself. What breaks if a listener calls off during emit?

Write promisePool(thunks, limit) that runs at most N async tasks at once and returns results in input order. Tasks are thunks (() => Promise), not promises — why does that matter?

Implement an O(1) LRU cache (get/put, fixed capacity) using only a JS Map — no hand-rolled linked list. How does Map give you the recency order for free?

Build a token-bucket rate limiter: capacity C, refill rate R tokens/sec, tryRemove() returns true (allow) or false (→ 429). No setInterval. How do you refill without a timer?

Write retry(fn, retries, baseMs) that retries a failing async call with exponential backoff plus jitter, and rethrows the last error after attempts are exhausted.

Implement debounce(fn, wait) and throttle(fn, wait). Explain the difference, and make sure both preserve this and the arguments.

Design a background job queue: producers enqueue work, workers process it, transient failures retry, and permanently-failing jobs land somewhere safe instead of blocking the queue.

Design a system that sends notifications across email, SMS, and push. It must not double-send on retry, must survive a provider outage, and must fan a single event out to many recipients.

Design a rate limiter for an API behind N app instances: e.g. 100 requests/min per API key, enforced consistently no matter which instance a request hits. Return 429 with a Retry-After when exceeded.