Capstone - Mock Loop & Self-Exam

Cursor screens with no AI allowed beyond autocomplete. For a manager who has spent two years reviewing code instead of writing it, that is the round most likely to embarrass you, so the fix is reps under the real constraint, starting now.

The bar is not LeetCode-hard puzzles. It is medium-hard problems with a backend flavor, the kind where a competent senior engineer writes clean, correct code and talks through complexity while they do it. Your muscle memory for that has atrophied if your day job is a calendar. Treat this section as a training plan, not a reading.

Set the conditions to match the screenDrill setup

1. 1Kill the AI. Disable Cursor TabCursor's original autocomplete: multi-line, edit-aware suggestions you accept with the Tab key.'s full suggestions or move to a plain editor; leave only basic word-completion. Pasting from a chat is the exact thing the screen forbids, so practicing with it is practicing the wrong skill.
2. 2Pick a backend-relevant language. Use the one you would actually reach for on the job - TypeScript, Python or Rust. Do not learn a new language for the interview; depth in one beats shallow breadth.
3. 3Time-box to ~45 minutes per problem. Stop when the clock stops, even mid-bug. The screen is timed and the recovery skill you need is finishing a coherent solution under a deadline, not a perfect one with unlimited time.
4. 4Narrate out loud. Talk through your approach, the data structure choice and the complexity as you type. Silence in a real screen reads as a candidate who can code but can't communicate and you are interviewing to lead engineers.

Build the problem set from backend primitivesWhat to practice

Skip the abstract graph trivia. Pull problems straight from the Core Services domain so the rehearsal doubles as system-design warm-up. Each of these is implementable in 30 to 45 minutes and maps to something you will own.

Add one or two stretch problems with distributed-systems texture: a fixed-window vs sliding-window counter, a dead-letter queue with replay or a small consistent-hashing ring. Five problems across a week is enough to get the rust off.

class TokenBucket {
  private tokens: number;
  private lastRefill: number;
  constructor(
    private readonly capacity: number,
    private readonly refillPerSec: number,
  ) {
    this.tokens = capacity;
    this.lastRefill = Date.now();
  }
  // Returns true if the request is allowed, false if throttled.
  allow(cost = 1): boolean {
    const now = Date.now();
    const elapsedSec = (now - this.lastRefill) / 1000;
    this.tokens = Math.min(
      this.capacity,
      this.tokens + elapsedSec * this.refillPerSec,
    );
    this.lastRefill = now;
    if (this.tokens >= cost) {
      this.tokens -= cost;
      return true;
    }
    return false;
  }
}

Score every run honestlySelf-rubric

The design round is your home turf as a Core Services EM and the way to waste it is to ramble. Run a timed 45-minute mock on a system you'll actually own and force yourself to lead with opinions the JD explicitly asks for.

Pick exactly one prompt and commit. Switching designs mid-interview reads as indecision and the panel would rather see you go deep than tour three shallow sketches.

The 45-minute timelineRun it on the clock

1. 10–8 min · Requirements and scope. Pin functional needs and the numbers: scale (1M+ DAU), latency targets and the consistency vs availability stance. Write the explicit non-goals so you don't get dragged into them.
2. 28–13 min · Delivery semantics and SLOs. State them out loud before you draw anything: at-least-once vs exactly-once, the SLO and error budget, the reliability target. This is the move most candidates skip and the one the JD rewards.
3. 313–28 min · High-level design. Sketch the components and the data flow. Define the service contract - the API between product surfaces and your infra layer - and where the boundaries sit.
4. 428–40 min · Deep-dive one component. Pick the hardest part (the retry engine, the token store, the queue) and go to the metal: data model, indexes, the hot path, the race conditions.
5. 540–45 min · Failure modes and wrap. Walk partial outage, poison messages, hot keys and how the system degrades gracefully. Close with what you'd build first and what you'd defer.

What you must state explicitlyThe non-negotiables

Score against the rubricSelf-grade

You can pass every technical round and still lose this one. The people-management panel decides whether you can hire, grow and lead engineers in a flat org and a thin story bank shows immediately under follow-up.

Run this as a real mock, not a re-read of your resume. Set up five prompts, answer each in two minutes and have a partner or a recording probe for the detail you skipped.

The five prompts to rehearseCover the EM canon

The fifth prompt is a changed-my-mind moment: a time evidence flipped a strong-held position of yours. Cursor's culture prizes truth-seeking over ego, so a candidate who can't recall ever being wrong reads as someone who isn't actually weighing evidence.

Answer in STAR, with teethThe structure

• Situation + Task: ten seconds of context, no backstory dump. The panel wants the decision, not the org chart.
• Action: the bulk of the answer, in first person - what you did, not what the team did. “We aligned” is a red flag; “I told the staff engineer the design wouldn't scale and why” is an answer.
• Result: a real metric and a real consequence. “Cut p99 from 1.2s to 300ms” or “the engineer was promoted within two quarters” beats “it went well.”
• One admitted mistake somewhere in every set of answers. Ownership is the trait being scored; a flawless hero in every story reads as someone editing the truth.

Tag each answer to a Cursor valueMake fit legible

Cursor's signature round is a paid, multi-hour working session - one or two ~8-hour days building a real project alongside the team. No whiteboard theater. They watch how you actually build and whether they'd want you on the next desk.

You can't fully replicate a paid onsite at home, but you can rehearse the two things that go wrong: environment friction that eats your hours and forgetting that as an EM you're being judged on collaboration as much as the artifact.

Run a self-simulationTwo to four hours, fresh codebase

1. 1Pick a real, small feature in an unfamiliar repo. Clone an open-source backend project you don't know and add something concrete - a rate-limit header, a webhook signature check, a retry wrapper. The unfamiliarity is the point; the onsite drops you into the team's codebase cold.
2. 2Pair if you possibly can. Grab a friend to drive or watch. Solo practice misses the entire collaboration signal, which is half of what this round scores for a manager.
3. 3Work the EM balance, not just the IC one. Contribute real code, but also think aloud about prioritization, where you'd unblock a teammate and what you'd raise in review. They're hiring a player-coach, so show both halves.
4. 4Timebox and ship something working. Even a small merged-quality change beats a sprawling half-built one. The onsite rewards taste and finish over ambition.

Kill environment friction before the daySetup speed

Hours lost to a broken setup are hours you can't get back and fumbling your own editor in front of the team that builds the editor is a bad look. Get fast and fluent before you arrive.

• Know your Cursor and editor shortcuts cold - multi-cursor, jump-to-symbol, integrated terminal, git, test runner.
• Have a clean dotfiles/setup you can stand up in minutes and rehearse cloning + building + testing an unfamiliar repo end to end.
• Pre-decide your debugging loop: how you read an unfamiliar codebase, where you set the first breakpoint, how you find the test that covers the area.

Solicit feedback on the right axisWhat actually gets scored

The mocks are worthless if you don't act on them. This section turns four messy scorecards into one ruthless final-week plan that spends your remaining time on the two things most likely to sink you.

Lay every dimension on one grid and score it cold. The point is to find your floor, not flatter your ceiling.

Score the full surfaceHonest 1–5 across the board

Pick your two weakest areasConcentrate, don't spread

With a week left, breadth is the enemy. Two areas drilled to depth move your odds more than seven touched lightly. If coding fundamentals and webhook semantics are your floor, the whole final week is rate limiters and at-least-once delivery and everything else is maintenance reps.

Re-read the JD line by lineNo responsibility uncovered

Go down every responsibility and qualification and confirm you can answer it with a concrete example, not a slogan. If a line has no story behind it, that's a hole the panel can find.

• Each responsibility (lead/grow the team, own auth, own webhooks, own agent backend, own SCM, define contracts, stay hands-on) gets one specific example you can speak to.
• Each qualification (distributed-systems depth, auth depth, event-driven architecture, people leadership, hands-on coding) gets a proof point - a system you ran, a metric you moved, an engineer you grew.
• Anywhere you have no example, decide now whether to build a story from real experience or to honestly frame it as a growth area you're hungry for.

Prepare sharp questions for themCuriosity is signal

The questions you ask are scored too. Generic ones (“what's the culture like?”) waste the slot; specific ones prove you understand the charter and you've already started doing the job in your head.

Build the one-page cheat sheetYour final artifact