50-Minute Interview Framework

Updated Nov 16, 2026 · 4 min read
On this page

    The interviewer says "Design a ride-hailing app" and starts a 50-minute clock. Without a plan, minutes vanish: ten on whether to use Postgres or Cassandra, fifteen drawing every microservice, and the interviewer's "how would you match riders to drivers quickly?" arrives with four minutes left. You knew the answer. You just never got there.

    A fixed plan for the 50 minutes solves this. It tells you what to do next at every moment, keeps you out of rabbit holes, and leaves the most time for the part that carries the most signal: the deep dives.

    How it works

    Time budget for 50 minutes: requirements 0–5, entities 5–8, API 8–12, high-level design 12–22, deep dives 22–43, wrap-up 43–50, with checkpoints at minute 12 and minute 22.
    Time budget for 50 minutes: requirements 0–5, entities 5–8, API 8–12, high-level design 12–22, deep dives 22–43, wrap-up 43–50, with checkpoints at minute 12 and minute 22.

    1. Requirements (minutes 0–5)

    • Functional: agree on the 2–3 core use cases. "Riders request a ride; nearby drivers get the request; both see live location." Park the rest out loud ("payments and ratings are out of scope unless you want them").
    • Non-functional, with numbers stated as assumptions: scale, latency, availability, consistency. Then say what each one means: "10,000 location updates per second means writes must be cheap; a match within 5 seconds means the search must be in memory."

    2. Core entities (minutes 5–8)

    List the main nouns and their key fields: Rider, Driver(location, status), Ride(rider, driver, status). No full schema yet; just enough for the API.

    3. API (minutes 8–12)

    A few endpoints or messages that cover the use cases:

    POST /rides             {pickup, dropoff}    → ride_id
    POST /drivers/location  {lat, lng}           (every 4 s)
    PATCH /rides/{id}       {status: accepted}

    Use REST unless the problem clearly needs streaming; then name the channel (WebSocket for live location).

    4. High-level design (minutes 12–22)

    Draw the simplest design that handles every use case: Client → API Gateway → services → databases. Walk each use case through the boxes once. Do not optimize yet; correctness first.

    5. Deep dives (minutes 22–43)

    Start simple, then fix the bottleneck you can name: at minute 12 the design is client, API gateway, service and database; after stating that reads are 100 to 1 and the database is the bottleneck, the
    Start simple, then fix the bottleneck you can name: at minute 12 the design is client, API gateway, service and database; after stating that reads are 100 to 1 and the database is the bottleneck, the minute-25 design adds a cache and read replicas.

    Pick the 2–3 parts most likely to break or most interesting for this problem, often:

    • the hottest read or write path (scale),
    • a correctness problem (double booking, double charging, ordering),
    • a latency target (matching within 5 seconds),
    • a failure (what happens when X is down).

    For each: state the problem with a number, give two or three options, choose one with a reason, and update the board. If the interviewer points somewhere, go there.

    6. Wrap-up (minutes 43–50)

    Walk one request through the final design, name the biggest remaining risk, and say what you'd do next with more time (monitoring, multi-region, cost). It shows you can see the whole system, not just the last thing you drew.

    Trade-offs and costs

    • The times are a guide, not a rule. Some interviewers want a longer requirements discussion; follow them. What matters is reaching the deep dives with real time left.
    • Level changes the mix. Mid-level candidates can spend longer on the high-level design; senior and staff candidates should reach deep dives sooner and lead them.
    • Estimation: quick, round numbers inside the requirements beat a separate five-minute calculation. Do math only when a decision depends on it.
    • Some rounds differ: product-style rounds stress API and data model; infrastructure rounds may leave out the API gateway because no client calls the system directly.

    When to reach for it

    Use the framework in every practice session until it is automatic. In the real interview, say the plan in one sentence at the start; it reassures the interviewer that you will manage the time. Keep a clock visible and check two moments: high-level design started by minute 12, first deep dive started by minute 22.

    Example

    "Design a ticket booking system for concerts."

    • Requirements (0–5): browse events, hold seats for 10 minutes, pay, get a ticket. Assume 50,000 seats per big event and 500,000 users in the first minute of sale. Meaning: heavy contention on the same seats, and a queue in front to protect the system.
    • Entities (5–8): Event, Seat(status, hold_expires_at), Booking, Payment.
    • API (8–12): GET /events/{id}/seats, POST /holds {seat_ids}, POST /bookings {hold_id, payment}.
    • High-level design (12–22): client → API gateway → Event Service (cached seat map) and Booking Service → Postgres; payments via a provider.
    • Deep dives (22–43): (1) no double booking: conditional update WHERE status='AVAILABLE'; (2) the on-sale spike: a virtual waiting room that admits users at a fixed rate; (3) hold expiry: a TTL plus a sweeper.
    • Wrap-up (43–50): walk a purchase through, name payment-provider failure as the main risk (idempotency keys and a pending state), mention monitoring of hold-to-purchase conversion.

    Common mistakes

    • No plan said out loud, so the interviewer can't tell where you're heading.
    • Designing for scale before the basic design works.
    • Spending 15 minutes on requirements or on database choice.
    • Changing the board without saying which bottleneck the change fixes.
    • Skipping the wrap-up and ending mid-sentence when time runs out.

    Say this in the interview

    "Here's my plan: about five minutes on requirements and scale, then entities and a small API, then a simple design that works end to end. After that I'd like to spend most of the time on the riskiest parts, probably seat contention and the on-sale spike, and finish by walking one booking through the system."

    Used in