Auction (eBay)

Design an eBay-style auction system — bidders compete on live listings under heavy contention near closing time, and the system must never accept a losing bid as the winner or let an auction close...

00

Practice checkpoints

The requirements are open as a taste. From the numbers onward, the full guide opens in the app.

  1. 01
    Clarify scope
  2. 02
    Requirements + scale
  3. 03
    API + data modelUnlocks in the app
  4. 04
    Draw architectureUnlocks in the app
  5. 05
    Deep diveUnlocks in the app
  6. 06
    Trade-off decisionUnlocks in the app
01

Requirements that shape the design

Do not only state requirements. Ask for them. Each card pairs the design constraint with a clarification question you can say out loud before drawing the architecture.

Functional requirements

01What makes a bid the new high bid?

A bid is accepted only if it is strictly higher than the current high; equal or lower bids get a clean rejection that carries the current price and the minimum next bid.

02Do we support max bids, or only direct bids?

Proxy bidding: a bidder sets a private ceiling and the system auto-raises on their behalf by the minimum increment; two ceilings resolve deterministically — the earlier one wins a tie.

03Who ends the auction — a clock on whose machine?

The server ends it: one close worker performs the open → closed transition exactly once, names the winner, and every bid arriving after that gets a definitive no.

04What happens to last-second snipers?

Policy decides: the design supports both a hard close and an auto-extend window (a bid inside the final N minutes pushes the close out, capped), switchable per marketplace.

05How does the outbid loser find out?

Promptly and asynchronously: an outbid event fans out to push/email right after the accepting write commits — never inside it.

06A buyer disputes the final price — what can we show?

The full bid history: every bid attempt is an append-only ledger row with server timestamp and outcome, so any close can be replayed and audited in a dispute.

Out of scopePayment capture and escrow after the winner is decided (authorize at close, never per bid) · Search, discovery, and listing ranking · Shill-bidding and fraud-ring detection (offline pipelines, off the bid-accept path)

Non-functional requirements

01How fast must a bid answer in the last ten seconds?

Tens of milliseconds to accept or reject, even in the closing seconds — the decision is one conditional write, not a workflow.

02Two bidders race — can the price ever go backwards?

The price never goes backwards and never forks: the accept is an atomic compare on the current-high row, so exactly one bidder holds the high at any instant.

03The close timer fires twice — do we get two winners?

Close fires exactly once: the open → closed transition is guarded by current state, so a duplicate or retried timer fire is a no-op.

04How stale can the price on a watcher’s screen be?

Watchers see the price within seconds: accepted bids push versioned updates, and the monotonic version lets clients drop out-of-order events.

05The hottest listing melts — does the site go with it?

One hot listing degrades only itself: contention is confined to that row, retries back off with jitter, and the rest of the site never notices.

Keep asking — the interview is a conversation

Real interviews probe far more than a tidy list. These are the scope questions that separate candidates who interrogate the problem from those who recite it.

  • Hard close like eBay, or auto-extend like most auction houses — which anti-sniping policy does product want, or must the design carry both?
  • How hot is the hottest listing — tens of bids per second in the last minute, or thousands?
  • Do we need proxy/max bids in v1, or only direct bids?
  • Do we touch payment at bid time at all, or authorize only the winner after close?
  • How fresh must the displayed price be for watchers — sub-second, or are a few seconds fine?
01

Unlock the full playbook for Auction (eBay)

Numbers, architecture diagram, API and data model, deep dives, expected topics, self-check, whiteboard starter, and common mistakes unlock inside the app.

02

Numbers that force architecture decisions

Locked in the app

03

Architecture path

Locked in the app

04

API and data model

Locked in the app

05

Deep dive directions

Locked in the app

+Series

Practice the related series