Capstone: Full Mock Loop & Self-Exam

Cursor's coding screens are not LeetCode in disguise. They hand you a slice of the actual job - a hot, streaming, failure-prone request path - and watch how you reason about it with the clock running.

Set a real timer. Open your primary language, turn the AI assist on the way the loop allows and solve the prompt below in 45 minutes. The point is to rehearse the conditions, not to admire a clean solution you wrote at leisure.

The promptDrill

Implement a consumer for a streaming token endpoint. It opens an SSE connection to a model provider, yields tokens as they arrive and has to survive the messy reality of a hot path: a slow first byte, a connection that dies mid-stream and a caller who cancels.

• Stream tokens from a mock provider that emits Server-Sent Events and may stall or drop the connection partway through.
• Enforce a time-to-first-token timeout and a separate idle timeout between tokens - a stream that goes quiet for 2s is dead, not slow.
• Support cancellation from the caller so an abandoned editor request stops consuming a provider slot immediately.
• On a retriable failure before any token has streamed, retry with exponential backoff and full jitter, bounded by a total retry budget.

A reference solve (TypeScript)One correct shape

type Token = { text: string };

interface StreamOpts {
  ttftMs: number;      // budget to first token
  idleMs: number;      // max gap between tokens
  maxRetries: number;  // retry budget (pre-first-token only)
  signal?: AbortSignal;
}

async function* streamTokens(
  open: (signal: AbortSignal) => Promise<AsyncIterable<Token>>,
  opts: StreamOpts,
): AsyncGenerator<Token> {
  for (let attempt = 0; ; attempt++) {
    const ctrl = new AbortController();
    const onAbort = () => ctrl.abort();
    opts.signal?.addEventListener("abort", onAbort, { once: true });
    let sawToken = false;
    try {
      const stream = await withTimeout(open(ctrl.signal), opts.ttftMs, ctrl);
      let deadline = opts.idleMs;
      for await (const tok of stream) {
        sawToken = true;
        yield tok;          // user has now seen output
        deadline = opts.idleMs;
      }
      return;               // clean end of stream
    } catch (err) {
      // Once a token streamed, a retry would duplicate output: fail loudly.
      if (sawToken || opts.signal?.aborted) throw err;
      if (attempt >= opts.maxRetries || !retriable(err)) throw err;
      const backoff = Math.random() * Math.min(2 ** attempt * 100, 2_000);
      await sleep(backoff, opts.signal);
    } finally {
      opts.signal?.removeEventListener("abort", onAbort);
    }
  }
}

Score your own tapeSelf-rubric

Stretch: hedged requests with a cost cap

If you finished early, add request hedging: when TTFT exceeds the p95 budget, fire a second request to a backup provider and take whichever streams first, then cancel the loser. The cap is the senior detail - at most one hedge per request, because a naive hedge doubles your provider bill at exactly the moment the fleet is already struggling.

The take-home is the JD's three flagship projects in miniature: a provider abstraction, failover and admission control, small enough to finish in a sitting but real enough to reveal whether you ship production code or a demo.

Box it at three hours and stop at the buzzer. What you choose to leave out and how honestly you document it, is graded as hard as what you build.

The promptDrill

Build a tiny inference gateway in front of two mock providers. It exposes one request interface, hides each provider's quirks behind an adapter and stays up when a provider misbehaves.

1. 1Provider-adapter interface. One interface both mock providers implement (complete(req): AsyncIterable<Token>). Provider A is fast but flaky; Provider B is slower but steady. Onboarding a third should be a new adapter, not a rewrite.
2. 2Timeouts and retries. Per-attempt timeout, bounded retry budget with jittered backoff and the idempotency rule from the coding screen carried through.
3. 3Failover. When Provider A fails health checks or trips a circuit breaker, route to Provider B without the caller noticing. Define what counts as unhealthy.
4. 4Admission control. A token-bucket rate limiter and a concurrency cap so a traffic spike sheds load instead of melting both providers.
5. 5Metrics. Emit at minimum: request latency (p50/p95/p99), error rate by provider and a failover counter. Numbers you could actually alert on.

Where the time goesThree-hour budget

Self-rubricGrade like the reviewer

This is the round where Cursor's actual job becomes the whiteboard. You're designing the platform that every Tab keystroke, Agent run and chat message flows through and the interviewer is listening for numbers, not adjectives.

Set 45 minutes. Talk the whole time. The prompt is deliberately the company's real problem.

Open with the budgets, not the boxesFirst five minutes

Before drawing a single box, segment the traffic by its latency and cost profile. The three surfaces are not one workload and saying so immediately is the strongest opening move you have.

Walk the request end to endThe journey

1. 1Edge / admission. Request lands, classified by surface and tenant. Admission control checks the token bucket and concurrency limit for its QoS class. Over budget? Tab sheds with a fast no-op; Agent queues.
2. 2Gateway / normalization. Map the internal request to the chosen provider's API shape via its adapter. Attach an idempotency key and a deadline that shrinks as the request ages.
3. 3Routing decision. Pick a provider by health, current latency, price and remaining rate-limit headroom. Tab prefers the cheapest fast provider; Agent prefers the highest-quality one.
4. 4Streaming passthrough. Proxy SSE tokens straight to the client. Track TTFT and inter-token latency live; an idle stream past budget is aborted.
5. 5Failover branch. Pre-first-token failure or breaker open routes down the fallback ladder. Post-first-token failure surfaces a clean error, never a duplicate stream.
6. 6Observe. Emit per-provider latency percentiles, error rates, failover counts and cost per request. These feed both the SLO dashboards and the routing decision in step 3.

Enumerate the failure branches out loudWhere points are won

Close by comparing your answer to the worked design in the routing and failover module. The gaps you find are this round's study list.

The design round tests whether you can shape the system. This round tests whether you understand the machine underneath it - and it moves fast, so vague answers get caught immediately.

Treat the rubric as a gap finder, not a score to admire. Mark the weakest proof, turn it into one practice rep and keep the artifact you would show an interviewer.

Have a partner read the rapid-fire prompts and stop you the instant you hand-wave. The hand-wave is the signal; mark it and study it.

Rapid-fire fundamentalsKnow these cold

Scenario: a provider's p99 spikes 3x at peakReason it out loud

1. 1Measure before acting. Split TTFT from ITL. Rising TTFT points at queueing or prefill saturation upstream; rising ITL points at decode contention or the provider shrinking your batch share.
2. 2Localize. Is it one provider or all of them? One region? Correlate with your QPS - did the spike come from us or them?
3. 3Mitigate. Shift health-based routing weight off the slow provider, enable hedging for the latency-critical surfaces with the cost cap and let admission control shed low-value Tab to protect Agent.
4. 4Verify. Watch p99 per surface recover and watch the hedge cost and failover counters so the cure isn't worse than the disease.

Scenario: cost is 30% over budgetName the lever and the risk

Cursor hires selectively for engineers who ship senior-IC work from week one. The behavioral round checks whether your stories prove that bar and whether you actually use the product and it detects superficial familiarity fast.

Have someone ask the questions and push back. A story you've only rehearsed in your head collapses on the first "what would you do differently?"

The five stories to have readySTAR, quantified

The fifth story is a real failure - one where you owned the miss, not a humblebrag in disguise. Interviewers at this bar trust the candidate who can name a genuine mistake and what it taught them.

Live authentic-usage drillPractice out loud

1. 1Pick a real task. Something you actually shipped with Cursor this week, with the repo, the surface (Tab, Agent, chat) and what you were trying to do.
2. 2Be specific. Where it nailed the context, where it lost the thread, what you accepted and what you rewrote by hand.
3. 3Give an honest critique. Name one real limitation you've hit - a latency annoyance, a context miss, a place a competitor does something better. Earnest praise with no critique reads as superficial.
4. 4Tie it to the role. Connect a latency or reliability frustration you felt to the inference path you'd be working on.

Self-rubricGrade your delivery

You've run the whole loop on yourself. Now grade it honestly and turn every weak area into a dated task, because a score with no remediation is just anxiety with a number on it.

Treat the rubric as a gap finder, not a score to admire. Mark the weakest proof, turn it into one practice rep and keep the artifact you would show an interviewer.

Score each area 1-5Be your own interviewer

The non-negotiablesConfirm all four

One-week checklistT-minus seven days

• Re-solve the streaming-consumer and gateway problems once more, timed, AI on.
• Run the system-design prompt out loud against a partner and compare to the worked design.
• Drill the rapid-fire fundamentals until each answer is under 20 seconds.
• Rehearse all five STAR stories with someone who pushes back and tighten why-Cursor to 90 seconds.
• Use Cursor on a real task daily so your authentic-usage answer stays fresh.

Day-before checklistT-minus one day

• Confirm your environment: editor, language, AI assist configured the way you'll actually use it.
• Re-read your own gateway README and the failure branches from the design round.
• Skim your STAR notes and your three questions for the team; do not cram new material.
• Sleep. A rested p99 beats a crammed p50.