System Design interview pathFree assessment

System Design Interview Practice Questions

Find decision gaps, strengthen your architectural judgment, and verify it across fresh scenarios.

Learner actions will appear after the current account is confirmed.

Sample readiness report

See your decision gaps before you practice

Take a free assessment to identify the tradeoffs weakening your design answers and the next decision worth repairing.

Sample readiness result68 / 100

See which interview decisions are strong and where your reasoning needs work.

Sample top gapWrite-path correctness under retries

Targeted repair: Strengthen durable event publication and idempotent processing.

ReportDecision gapsPass PlanTargeted repairsUnlocksDecision Drills + Readiness Exam
01Answer system design scenarios
02Work your Pass Plan
03Complete the Readiness Exam
See it in action

Watch CramHQ turn one missed tradeoff into a defensible design decision.

CramHQ

Find the weak decision. Strengthen the design.

Watch one missed tradeoff become a defensible architecture decision.

How CramHQ finds the tradeoff weakening your design

Try it now

Free system design practice questions

Ten practice questions from the CramHQ system design bank, with answers and explanations. No signup needed. When you are ready, start the free assessment. CramHQ ranks your weak spots across the interview by the points they cost, and your Pass Plan starts with the costliest.

Question 1 of 10Interview Framing and Requirements

A team is designing deletion for a chat product after customer support reports that users expect removed messages to stop appearing in conversations. Product has not decided whether compliance review, abuse investigation, or account recovery can retain copies. The first architecture review must choose a defensible storage and workflow direction without blocking all engineering. Which recommendation is safest?

  1. A. Replace deleted messages with tombstones in the primary database, defer all replica cleanup, and treat audit, recovery, and purge details as operational runbook work.
  2. B. Physically erase every copy immediately after the user action, and document that legal or recovery workflows must request exports before deletion is triggered.
  3. C. Remove content from user-facing reads, record deletion intent durably, and make any retained-copy behavior a named approval boundary before physical purge semantics are finalized.
  4. D. Keep all deleted content in cold storage indefinitely, hide it from normal reads, and expose restoration only through an internal review workflow.
Show answer and explanation

Answer: C

This preserves the known conversation behavior and avoids pretending the missing retention rule is settled. The boundary is explicit: user-visible removal can proceed, while deeper storage disposal depends on a policy decision.

“Product has not decided whether compliance review, abuse investigation, or account recovery can retain copies.”

What to notice

This quote says the retention boundary is unresolved, so the safest recommendation must avoid assuming either immediate purge or indefinite retained copies.

How to decide

Scope the decision: separate the settled user-facing removal behavior from retained-copy and purge semantics that need approval.

If you picked A

Why it is tempting: Tombstones look incremental and can support user-facing hiding quickly.

Why it is wrong: Unresolved retention and purge semantics must be named design inputs, not deferred as runbook work.

If you picked B

Why it is tempting: Immediate erasure appears privacy-preserving and gives a simple deletion story.

Why it is wrong: Do not encode a missing retention decision as immediate irreversible deletion across every copy.

If you picked D

Why it is tempting: Cold storage seems to keep optionality while still hiding deleted content from normal reads.

Why it is wrong: Do not turn undecided retention policy into indefinite storage just because future workflows might need data.

Question 2 of 10Capacity Estimation and Constraint Translation

A team is preparing collaborative editing changes for a document product with 4 million monthly accounts and about 600,000 daily editors. Editing clusters during weekday mornings, and each change must update every viewer of the open document. A previous test divided daily requests evenly across the day; production then saw connection queues spike while storage stayed idle. Which recommendation is the safest next decision before release?

  1. A. Estimate busiest 15-minute editing windows from active documents, viewers per document, and edit rates; include session lifetimes and fan-out; validate with replayed traces and alert on queue growth.
  2. B. Estimate total daily document changes from daily editors, divide by seconds per day, double it for headroom, and run a steady-rate test against the full stack.
  3. C. Estimate average open documents per day and storage writes per edit, scale the database write tier first, and monitor write latency as the primary release guardrail.
  4. D. Estimate capacity from registered accounts times a worst-case edit rate, provision for that ceiling, and skip trace validation because the bound is intentionally conservative.
Show answer and explanation

Answer: A

This keeps the estimate tied to the interval and component that failed. It accounts for shared-view amplification and connection duration, then checks the result against observed traces with a signal that exposes overload early.

“Editing clusters during weekday mornings”

What to notice

Clustered activity means daily averages are unsafe; the decision must model the busiest relevant interval.

How to decide

Scope the estimate to the peak window before comparing capacity or validation options.

If you picked B

Why it is tempting: Dividing by seconds per day and adding headroom looks quantitative and easy to test across the stack.

Why it is wrong: For bursty collaboration, estimate the busiest relevant interval and preserve fan-out and session effects instead of smoothing work across a full day.

If you picked C

Why it is tempting: Every edit does create a write, so database scaling and write latency can look like a concrete release guardrail.

Why it is wrong: Translate usage into the component on the hot path that actually saturates; here, live viewer fan-out and connections dominate the release risk.

If you picked D

Why it is tempting: A worst-case ceiling sounds conservative and can seem safer than estimating messy real behavior.

Why it is wrong: Use realistic peak behavior and validate the stressed path; conservative bounds do not remove the need to test fan-out, queues, and session behavior.

Question 3 of 10API, Data Model, and Access Patterns

A ticket marketplace serves seat availability from a fast browsing index that is refreshed from purchase events and can lag by a few seconds. During popular releases, two buyers can see the same seat as open, but confirmation must never double-sell or charge for an unavailable seat. The team wants to keep browsing latency low without adding manual reconciliation. Which recommendation is safest?

  1. A. Add short-lived distributed locks around seat IDs before writing purchases, and let the browsing index remain the source used to decide availability.
  2. B. Before accepting a hold, perform a conditional update on the seat record in the durable write store; publish changes to rebuild search pages asynchronously.
  3. C. Make the browsing index synchronously update on every purchase and use its current availability field to approve holds before charging users.
  4. D. Accept holds from the browsing index, then run a reconciliation worker that cancels duplicate holds and refunds losing buyers within a few seconds.
Show answer and explanation

Answer: B

This keeps the low-latency browsing path useful while placing the irreversible decision at the record that can reject a competing claim atomically. The boundary is the moment a user commits, where stale presentation data is no longer sufficient.

“fast browsing index that is refreshed from purchase events and can lag by a few seconds”

What to notice

This cue says the browsing path is a derived view that is allowed to be stale, so it should not be the authority for an irreversible purchase decision.

How to decide

Separate discovery from commitment: let the index serve browsing, then verify the final hold against the authoritative write record.

If you picked A

Why it is tempting: Locks around seat IDs can look like they serialize competing buyers during a popular release.

Why it is wrong: A lock can coordinate attempts, but the final hold must be accepted only by the durable record that owns the seat invariant.

If you picked C

Why it is tempting: Synchronous updates sound like they remove the lag that caused two buyers to see the same seat.

Why it is wrong: A serving index can be optimized for freshness, but ownership must still be decided by the durable write model that enforces atomic state transitions.

If you picked D

Why it is tempting: A reconciliation worker preserves fast confirmation and can seem operationally simple when conflicts are rare.

Why it is wrong: Do not accept an irreversible hold or charge from stale presentation data when the requirement says the invariant must already hold before commitment.

Show all 10 practice questions
Question 4 of 10Service Communication, Edge, and Traffic Management

During a flash sale, a commerce API kept returning success on its status endpoint and stayed behind the load balancer after its connection pool to the stock reservation store wedged. Instances still accepted HTTP connections, so scaling added more unusable capacity while checkout attempts failed until operators drained nodes manually. Which change is the safest next decision?

  1. A. Use a cheap process probe for restarts, a bounded reservation-store exercise for traffic admission, and scheduled synthetic checkouts against the recovery route.
  2. B. Use a cheap process probe for restarts, drain only after real checkout errors exceed a threshold, and run manual recovery tests after incidents.
  3. C. Use the existing status endpoint for restarts, require only an HTTP accept check for traffic admission, and add dashboards for checkout failure rate.
  4. D. Use a deep dependency sweep for restarts, the same sweep for traffic admission, and block all regions when any dependency probe fails.
Show answer and explanation

Answer: A

This keeps restart decisions local while preventing instances that cannot complete the critical operation from receiving traffic. The recovery route is checked separately, so broad investigation signals do not block every admission decision.

“connection pool to the stock reservation store wedged”

What to notice

The failed component is on the checkout critical path, so the traffic gate must prove that dependency path works before the instance receives customer traffic.

How to decide

Scope the health check to the critical operation that failed, then compare whether each option checks that path before routing traffic.

If you picked B

Why it is tempting: A threshold on real errors looks practical because it uses the exact user-facing failure mode.

Why it is wrong: Traffic admission should prevent known-bad capacity from serving customers by proving the critical path before routing traffic, not wait for enough customer failures.

If you picked C

Why it is tempting: Dashboards and HTTP accept checks are easy to add and can make the system look more observable.

Why it is wrong: A traffic health check must reflect the critical operation needed for the request path; visibility does not fix a routing gate that admits unusable instances.

If you picked D

Why it is tempting: A deep sweep sounds thorough and can appear to catch more failures before users see them.

Why it is wrong: Scope health checks to the decision they drive: restart probes should stay local, and traffic admission should test the bounded critical path without turning unrelated dependency trouble into fleet-wide unavailability.

Question 5 of 10Read Path Design and Caching

During a flash sale, the first checkout screen becomes slow even though web servers are under 40% CPU. Traces show most time is spent repeatedly reading item eligibility and amount data; those values change through controlled updates, and the final submit path already verifies the order before committing it. Which recommendation is the safest next architecture decision?

  1. A. Store complete checkout pages at the edge per shopper, purge them every minute, and keep final submission checks on the authoritative store.
  2. B. Serve a short-lived read copy for item quote inputs, refresh it on controlled updates, and keep final submission checks on the authoritative store.
  3. C. Cache completed reservation decisions for duplicate carts, reuse them for later attempts, and keep final submission checks on the authoritative store.
  4. D. Memoize each web server's last quote responses, expire entries quickly, and keep final submission checks on the authoritative store.
Show answer and explanation

Answer: B

This targets the repeated read work causing delay and load, while the commit path still protects correctness. The freshness boundary is acceptable because final submission remains authoritative.

“most time is spent repeatedly reading item eligibility and amount data”

What to notice

This quote identifies the actual hot path: repeated reads of quote inputs, not page rendering, web CPU, or reservation outcomes.

How to decide

Scope the cache to the repeated read work first, then compare whether each option accelerates that same operation.

If you picked A

Why it is tempting: Edge caching sounds fast, and the choice keeps final submission checks, so it appears to preserve correctness.

Why it is wrong: Cache the data or computation on the traced hot path, not a nearby presentation layer, when traces identify repeated backend reads as the bottleneck.

If you picked C

Why it is tempting: Duplicate carts make outcome reuse sound efficient, and the choice still mentions final submission checks.

Why it is wrong: Do not cache authoritative reservation or commit decisions to solve a read-path bottleneck; cache the reusable read inputs instead.

If you picked D

Why it is tempting: Fast expiry and quote-response memoization sound aligned with freshness and the named read path.

Why it is wrong: For broad flash-sale demand, place shared read-side acceleration where the fleet can reuse it coherently, not only inside each web server instance.

Question 6 of 10Write Path Design and Async Processing

A profile service emits account updates used by cache eviction, risk scoring, and monthly reconciliation. Adding a new processor currently changes which existing processor receives some updates, and correcting a processing bug requires expensive database backfills. Which architecture decision is the safest next step?

  1. A. Use a durable work queue partitioned by account, let processors compete for messages, and retry failed tasks with dead-letter handling.
  2. B. Use separate durable work queues per processor, copy each update to every queue, and scale consumers independently with per-queue retries.
  3. C. Use immediate fan-out notifications to all processors, partition by account, and rely on each processor's local store for missed updates.
  4. D. Use an append-only event log with retention, partition by account, give each processor its own cursor, and require idempotent downstream writes.
Show answer and explanation

Answer: D

This keeps the shared facts durable while each processor advances independently. Partitioning bounds ordering to the entity that needs it, and idempotent writes make retries safe without coupling processors together.

“used by cache eviction, risk scoring, and monthly reconciliation”

What to notice

Multiple processors need the same account updates, so the design must support independent consumption rather than one worker claiming each message.

How to decide

Separate task execution from fact distribution; eliminate designs where consuming an update by one processor prevents another processor from seeing it.

If you picked A

Why it is tempting: Durable queues, partitioning, retries, and dead-letter handling sound operationally robust for background work.

Why it is wrong: Use a competing work queue when one task should be performed once; use a retained event log when every processor needs its own view of the same fact stream.

If you picked B

Why it is tempting: A queue per processor gives each processor its own retry path and avoids competing consumers stealing work from each other.

Why it is wrong: When processors need shared historical facts, prefer one retained append-only log with per-consumer cursors over copied queues that multiply truth surfaces.

If you picked C

Why it is tempting: Immediate fan-out appears to ensure every processor hears about each update as it happens.

Why it is wrong: Live fan-out is not enough when corrected processors, late processors, or backfills need prior facts from an authoritative retained source.

Question 7 of 10Partitioning, Sharding, and Hotspot Management

A ticketing marketplace keeps live seat state during major onsales. The busiest operations mutate or render small seating areas within one show, while account-support lookups by buyer happen rarely and can lag. A prior design spread records by buyer and made each onsale fan out across many ranges, causing slow map refreshes and lock contention. Which storage layout is the safest next decision?

  1. A. Group seat-state rows by show area, order by seat, and maintain an asynchronous buyer lookup view for support workflows.
  2. B. Group seat-state rows by seat identifier hash, order by show, and rebuild each live seating area from scatter-gather reads.
  3. C. Group seat-state rows by buyer, order by purchase time, and query all affected buyers when refreshing a live seating area.
  4. D. Group seat-state rows by venue and calendar day, order by show, and filter seating areas inside each larger range.
Show answer and explanation

Answer: A

This keeps the critical mutations and refreshes local to the unit the system repeatedly reads and updates together. The buyer path is outside the freshness boundary, so a delayed derived view is safer than shaping the primary layout around it.

“The busiest operations mutate or render small seating areas within one show”

What to notice

This identifies the unit that the dominant workflow must read or mutate together, so it should drive the primary storage boundary.

How to decide

Scope the partition key to the smallest coherent area named by the busiest operation before comparing secondary lookup paths.

If you picked B

Why it is tempting: Hashing individual seats appears to reduce hot partitions and spread load uniformly.

Why it is wrong: Do not scatter records that the dominant workflow repeatedly reads or updates as one small coherent area.

If you picked C

Why it is tempting: The previous buyer-based layout makes account-support queries straightforward and familiar.

Why it is wrong: A rare, lag-tolerant lookup should usually be served by a derived path, not by shaping the primary store against the dominant mutation boundary.

If you picked D

Why it is tempting: Venue and day sound operationally natural because onsales are scheduled around events and calendars.

Why it is wrong: The primary partition boundary should be no broader than the dominant workflow needs when broader grouping mixes unrelated hot traffic.

Question 8 of 10Consistency, Correctness, and Concurrency Control

An appointment platform sends provider notifications for scheduled visits. During regional failover, two scheduler replicas sometimes pick the same due visit. Duplicate sends can create conflicting provider commitments; a delayed send can be retried. A worker can also crash after the provider accepts a notification but before local completion is recorded. Which near-term design best protects the business invariant before traffic increases?

  1. A. Let every active replica send due notifications immediately, then reconcile duplicate provider commitments after failover by canceling extras.
  2. B. Add worker concurrency limits, retry backoff, and backlog alerts so failover sends less duplicate traffic under load.
  3. C. Partition visits by provider, run one scheduler per partition, and manually rebalance partitions during regional failover.
  4. D. Claim each due visit with a guarded state transition, send with a stable notification key, and reconcile accepted send outcomes before retrying.
Show answer and explanation

Answer: D

This is best supported by the stem because it addresses both failure modes: guarded claiming prevents competing schedulers from owning the same visit, and a stable send key plus outcome reconciliation limits duplicate external commitments after crashes.

“Duplicate sends can create conflicting provider commitments; a delayed send can be retried.”

What to notice

This quote establishes the invariant: duplicates are harmful, while delay is acceptable through retry. The best answer must prevent or idempotently collapse duplicate external commitments, not optimize throughput first.

How to decide

Scope the decision around the forbidden outcome. Eliminate answers that allow duplicate sends first, then compare which remaining design handles retry safety.

If you picked A

Why it is tempting: Reconciliation sounds operationally practical because it eventually removes extra commitments.

Why it is wrong: If the external effect itself breaks the business rule, the design must prevent or idempotently collapse duplicate sends before providers can accept conflicting commitments.

If you picked B

Why it is tempting: Concurrency limits, backoff, and alerts are familiar reliability controls and can reduce the frequency of duplicate work.

Why it is wrong: Controls that reduce pressure do not protect a correctness invariant unless they also enforce single ownership or idempotent external effects across retries and crashes.

If you picked C

Why it is tempting: One scheduler per provider partition appears to remove duplicate picking during steady-state operation.

Why it is wrong: A partitioning scheme protects the invariant only if ownership remains unambiguous during failover and the send path is safe when a worker crashes after external acceptance.

Question 9 of 10Reliability, Failure Handling, and Degradation

A typeahead product adds a generated rewrite step before querying its index. A stricter input-hardening change is ready, but previous revisions caused rewrite latency spikes; client retries then saturated the search tier. Product accepts losing speculative suggestions briefly, but submitted searches must receive an explicit outcome. Which architecture decision is safest?

  1. A. Run the hardening change on a small traffic slice, cache rewrite results aggressively, let committed searches wait behind suggestions, and roll back on error-rate alarms.
  2. B. Disable client retries, run the hardening change globally, prioritize committed searches in workers, and use manual operator approval before rejecting any request.
  3. C. Run the hardening change on a small traffic slice, cap speculative rewrites, return explicit busy responses for committed searches, and roll back on queue age or retry-rate alarms.
  4. D. Deploy the hardening change globally, increase rewrite worker concurrency, keep all requests queued, and alert only when search-tier latency exceeds its target.
Show answer and explanation

Answer: C

This preserves the user-visible contract while bounding optional work and limiting exposure to the risky change. It treats retry amplification and queue age as control signals before the search tier is overwhelmed.

“previous revisions caused rewrite latency spikes; client retries then saturated the search tier”

What to notice

This quote identifies the failure path: latency in the rewrite step can trigger retries that overload the downstream search tier, so the answer must bound admitted work before saturation spreads.

How to decide

Scope the blast radius first, then compare which option uses early pressure signals instead of waiting for downstream failure.

If you picked A

Why it is tempting: A canary rollout and aggressive caching look like prudent safeguards for a risky rewrite change.

Why it is wrong: Admission control must separate optional work from committed work and choose what gets admitted, delayed, or rejected before shared capacity is exhausted.

If you picked B

Why it is tempting: Prioritizing committed searches addresses the visible user contract, and disabling retries seems to remove the retry-amplification symptom.

Why it is wrong: Overload controls need automatic limits at the point work enters the system, especially during a risky rollout.

If you picked D

Why it is tempting: Increasing concurrency can look like a direct fix for latency at the rewrite step.

Why it is wrong: When overload can propagate downstream, admission control must bound queued work and surface pressure before the dependency is saturated.

Question 10 of 10Performance, Latency, and Tail Behavior

A ticketing checkout endpoint now has 4-second p95 latency after adding receipt generation, recommendation updates, and partner notifications. The page cannot advance until the customer is told accepted or declined, and confirmed seats must never be double-sold. Which architecture change is the safest next decision?

  1. A. Run payment, seat claim, order record, receipts, recommendations, and notifications concurrently; respond once payment and any one persistence write succeeds.
  2. B. Keep all checkout work before responding, but add more application instances and per-dependency timeouts for receipts, recommendations, and partner notifications.
  3. C. Return a provisional confirmation after payment authorization; perform the seat claim, order record, receipts, recommendations, and notifications asynchronously with compensating cancellation if needed.
  4. D. Complete payment authorization, atomic seat claim, and order record before responding; hand off receipts, recommendations, and partner notifications durably with retries and lag alerts.
Show answer and explanation

Answer: D

This preserves the customer-visible outcome and seat correctness boundary while removing consequence work from the latency-sensitive exchange. Durable handoff, retries, and lag signals prevent delayed work from silently disappearing.

“The page cannot advance until the customer is told accepted or declined”

What to notice

The response must reflect the authoritative checkout outcome before the page advances, so designs that return provisional success before outcome-defining writes are unsafe.

How to decide

Scope the foreground path to the operations that make accepted or declined true, then compare which options defer only consequence work.

If you picked A

Why it is tempting: Concurrent execution can reduce p95 latency and looks attractive when several independent dependencies were added to the endpoint.

Why it is wrong: Parallelize only after preserving the payment authorization, atomic seat claim, and order-record boundary required before the customer sees accepted.

If you picked B

Why it is tempting: More instances and timeouts are familiar latency controls, and they may cap some dependency waits without changing business semantics.

Why it is wrong: First remove safe consequence work from the user-visible path; add capacity only after the blocking path contains the required outcome-defining operations.

If you picked C

Why it is tempting: Provisional confirmation can look like a fast user experience, and compensation sounds like a way to repair failures later.

Why it is wrong: Do not defer operations that determine whether the customer should be accepted or declined; defer only consequence work after the authoritative outcome is recorded.

CramHQ links wrong answers to the mistake behind them. Start with the free assessment, and CramHQ keeps finding your gaps as you practice and adds a repair for each to your Pass Plan.

Why study with CramHQ

Practice system design tradeoffs that hold up.

Start with the free System Design assessment. CramHQ uses your result to rank the next step, explain the decisions that matter, and check you again.

Learner actions will appear after the current account is confirmed.

  1. A clear next step, chosen for you

    The Pass Plan ranks gaps by the points they cost and opens the top repair.

  2. Understand why an answer works

    The reasoning behind the right answer and where the alternatives break.

  3. Prove it on a retest

    A fresh question on the same decision verifies the gap is closed.

  4. Track it on your readiness map

    Strengthened areas change colour; pick the next priority from what is left.

  • Flashcards saved from your repairs
  • Optional hints when you are stuck
  • Timed simulations at exam pace
Interview decision coverage

Practice the decisions strong system design interviews demand.

Practice emphasis spans requirements, estimation, APIs and data, communication, caching, write paths, partitioning, consistency, reliability, performance, observability, security, cost, migration, specialized systems, and end-to-end synthesis.

Interview Framing and Requirements

8% practice emphasis

15 decision areas

Capacity Estimation and Constraint Translation

7% practice emphasis

18 decision areas

API, Data Model, and Access Patterns

7% practice emphasis

18 decision areas

Service Communication, Edge, and Traffic Management

4% practice emphasis

15 decision areas

Read Path Design and Caching

7% practice emphasis

15 decision areas

Write Path Design and Async Processing

8% practice emphasis

18 decision areas

Partitioning, Sharding, and Hotspot Management

7% practice emphasis

15 decision areas

Consistency, Correctness, and Concurrency Control

8% practice emphasis

21 decision areas

Reliability, Failure Handling, and Degradation

8% practice emphasis

18 decision areas

Performance, Latency, and Tail Behavior

7% practice emphasis

15 decision areas

Observability, SLOs, and Operations

8% practice emphasis

15 decision areas

Security, Abuse, Privacy, and Permissions

3% practice emphasis

18 decision areas

Cost, Complexity, and Operational Tradeoffs

4% practice emphasis

15 decision areas

Migration, Rollout, and Evolution

3% practice emphasis

15 decision areas

Specialized System Patterns and Data Structures

3% practice emphasis

24 decision areas

System Design Synthesis and Challenge Handling

8% practice emphasis

15 decision areas

Decision Drills after assessment

See what the Decision Drills unlock after your assessment.

Take the assessment first so CramHQ can connect each Decision Drill to your readiness report and Pass Plan.

01Decision Drill

Requirements and Scope

Turn ambiguous prompts into explicit requirements, constraints, scope boundaries, and useful clarifying questions.

Scenarios
15
Timer
Optional
02Decision Drill

Capacity and Constraint

Estimate traffic, concurrency, storage, bandwidth, fanout, compute, and connection limits so scale assumptions drive the design.

Scenarios
18
Timer
Optional
03Decision Drill

API, Data Model, and Access Pattern

Choose API boundaries, sources of truth, indexes, schemas, and storage models from concrete read and write patterns.

Scenarios
18
Timer
Optional
04Decision Drill

Service Communication and Traffic

Decide where protocols, gateways, proxies, load balancing, routing, health checks, and failover belong.

Scenarios
15
Timer
Optional
05Decision Drill

Read Path and Caching

Balance latency and freshness with cache placement, invalidation, CDNs, read models, and hot-key controls.

Scenarios
15
Timer
Optional
06Decision Drill

Write Path and Async Processing

Design synchronous and asynchronous boundaries, queues, workers, retries, dead-letter handling, backpressure, and reliable event publication.

Scenarios
18
Timer
Optional
07Decision Drill

Partitioning and Hotspot

Choose partition and sharding keys, detect hot partitions, and rebalance without breaking locality or tenant isolation.

Scenarios
15
Timer
Optional
08Decision Drill

Consistency and Concurrency

Protect invariants with consistency models, state machines, idempotency, concurrency control, transactions, sagas, and replication coordination.

Scenarios
21
Timer
Optional
09Decision Drill

Reliability and Degradation

Handle dependency, overload, and regional failures with admission control, graceful degradation, replay, restore, and disaster recovery.

Scenarios
18
Timer
Optional
10Decision Drill

Performance and Tail-Latency

Trace critical paths and reduce tail latency through precomputation, bounded fanout, parallelism, and queueing control.

Scenarios
15
Timer
Optional
11Decision Drill

Observability and Operations

Define useful SLOs and connect metrics, saturation, logs, traces, alerts, incident response, and repair verification.

Scenarios
15
Timer
Optional
12Decision Drill

Security, Abuse, and Privacy

Place authentication and authorization correctly while designing rate limits, anti-abuse controls, isolation, data lifecycle protection, and secure operations.

Scenarios
18
Timer
Optional
13Decision Drill

Cost and Operational Tradeoff

Identify dominant cost drivers and justify managed services, operational ownership, phased complexity, and build-versus-buy decisions.

Scenarios
15
Timer
Optional
14Decision Drill

Migration and Rollout

Plan compatibility, phased rollout, backfills, reindexing, dual writes, cutovers, rollback, and recovery without losing correctness.

Scenarios
15
Timer
Optional
15Decision Drill

Specialized Systems

Apply the right patterns for collaboration, search, geospatial, media, time series, ranking, approximate structures, IDs, and rate control.

Scenarios
24
Timer
Optional
16Decision Drill

System Design Synthesis

Identify the highest-leverage repair, preserve requirements, defend tradeoffs, handle ambiguity, and connect decisions across the full design.

Scenarios
15
Timer
Optional
Final readiness check

Validate the full interview loop under time.

Use this after the Decision Drills to validate system design judgment, pacing, and breadth.

FinalReadiness exam
Readiness target80 / 100

System Design Readiness Exam

Scenarios
30
Time
1 hr
Mode
Timed

Start with the free assessment; full access unlocks the System Design Readiness Exam.

Guided architecture practice

Case Labs

Work through an evolving system one checked decision at a time. Case Labs are untimed and formative: they do not change mastery, readiness, or your Pass Plan.

Case Lab Assessment first

The Last Seat

Protect scarce inventory through contention, delayed payments, regional isolation and a writer migration. Finish by choosing a safe offline control under a different authority model.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The p99 Cliff

An untimed, formative Case Lab about diagnosing a slow request path, testing bounded repairs and preserving authorization, freshness and valid service.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The Tenant That Outgrew Its Home Shard

An untimed, formative Case Lab about choosing partition keys, spreading an oversized tenant, moving live data safely and protecting its neighbors.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

When a Successful Write Disappears

An untimed formative Case Lab about acknowledged-write durability, quorum limits, fresh reads and safe replica recovery.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

One Poison Job Behind a Million Valid Ones

An untimed formative Case Lab about durable task delivery, account ordering, idempotent effects and controlled replay.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The Token Budget Behind the Stream

An untimed formative Case Lab about interactive inference objectives, token-dependent memory, prefill/decode scheduling and safe capacity recovery.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

A Cache Hit from the Wrong Tenant

An untimed formative Case Lab about measured cache benefit, tenant-safe reuse, current object authorization and bounded freshness.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The Celebrity Post and the Drifting Feed View

An untimed formative Case Lab about fanout budgets, authoritative posts, materialized timelines and verifiable freshness recovery.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The chat restart that became a reconnect storm

An untimed, formative Case Lab on persistent connections, rollout recovery, presence and geographic latency.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

A key-value service before the fashionable architecture

An untimed, formative Case Lab on sufficient architecture, measured bottlenecks and justified distribution.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

A rate limit is not a fair queue

An untimed, formative Case Lab on admission fairness, identity uncertainty and exact scarce-resource controls.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The committed change with no event

An untimed, formative Case Lab on durable account changes, publication intent, replay and remote-effect recovery.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

Paid, expired, and not confirmed

An untimed, formative Case Lab on guarded ownership transitions, late payments, compensation and truthful status.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The healthy replica that cannot safely take over

An untimed formative Case Lab about routing under regional failure without inventing data authority.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The paused editor lease and the hot document

An untimed formative Case Lab about concurrent editing, fenced authority and operation semantics.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

When decoupling becomes an infinite queue

An untimed formative Case Lab about bounded admission, useful deadlines and accountable degraded service.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

Yesterday's events arrive during today's hotspot

An untimed, formative Case Lab: Yesterday's events arrive during today's hotspot.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

A resumable upload is more than a blob bucket

An untimed, formative Case Lab: A resumable upload is more than a blob bucket.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

An inbox index is not a search engine

An untimed, formative Case Lab: An inbox index is not a search engine.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The Relevant Passage You May Not Read

An untimed formative Case Lab about permitted retrieval, versioned evidence, hybrid candidates and grounded answers.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The Scheduler Leader That Came Back Late

An untimed formative Case Lab about expired leases, store-enforced authority and useful scheduler throughput.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The Agent That Resumed the Wrong Action

An untimed formative Case Lab about agent authority, confined tools, durable execution history and external-effect uncertainty.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The Fleet That Was Busy but Made No Progress

An untimed formative Case Lab about synchronized GPU training, collective bandwidth, complete recovery state and useful progress under preemption.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

Nearby is not necessarily eligible or best

An untimed formative Case Lab about spatial coverage, current eligibility and ranking quality.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The model changed; did the data?

An untimed formative Case Lab about reproducible data, feature timing, evaluation and model release.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The rebuilt index is still yesterday's truth

An untimed formative Case Lab about online backfill, versioned change capture and safe search cutover.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The upload forecast that forgot memory

An untimed, formative Case Lab: The upload forecast that forgot memory.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The regional chat contract nobody wrote down

An untimed, formative Case Lab: The regional chat contract nobody wrote down.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

Every replica faithfully copied the corruption

An untimed, formative Case Lab: Every replica faithfully copied the corruption.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

Premiere Night Beyond the CDN Hit Rate

An untimed formative Case Lab about media egress, correlated cache misses and bounded playback authority.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The Green Pipeline with Late Users

An untimed formative Case Lab about user-visible delivery, honest SLO denominators and safe operational response.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The Flag Does Not Roll Back Your Data

An untimed formative Case Lab about representative canaries, semantic compatibility and the difference between exposure rollback and persisted-state reversal.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The File Service That Keeps Growing in Scope

An untimed formative Case Lab about deriving a bounded file-sharing design from required flows, durable completion, retry intent and explicit consistency expectations.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

When the event log, not the row, owns the truth

An untimed formative Case Lab about immutable acceptance, derived views and honest replay.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The tiny authorization response with a giant tail

An untimed formative Case Lab about required fanout, deadline budgets and valid authorization goodput.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The report everyone opens at nine

An untimed formative Case Lab about hot-key reuse, bounded worker scheduling and honest report completeness.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The diagnostic copy that outlived its tenant

An untimed, formative Case Lab: The diagnostic copy that outlived its tenant.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

An idle crawler that must not fetch faster

An untimed, formative Case Lab: An idle crawler that must not fetch faster.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The provider that cannot tell you whether it sent

An untimed, formative Case Lab: The provider that cannot tell you whether it sent.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The Fast Rollback That Would Replay a Charge

An untimed formative Case Lab about incident evidence, valid payment recovery and honest error-budget decisions.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

Safe Stale Configuration During a Region Outage

An untimed formative Case Lab about bounded offline configuration, publication authority and sustainable degraded service.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The Link Service with a Five-Year Roadmap

An untimed formative Case Lab about operational ownership, sustainable maintenance and measured reversible evolution of a redirect service.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

A Correct Aggregate Is Not a Row-for-Row Copy

An untimed formative Case Lab about recovering derived aggregates through explicit source boundaries, transformation-aware verification and honest freshness contracts.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

The ranker that won the wrong experiment

An untimed formative Case Lab about ranking objectives, comparable experiments and preserved serving guarantees.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

One launch, three tempting rewrites

An untimed formative Case Lab about evidence-based incident scope, contention repair and preserved ownership.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

A million pixels that no other viewer can reuse

An untimed, formative Case Lab: A million pixels that no other viewer can reuse.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

A Reliability Promise Bigger Than the On-Call Team

An untimed formative Case Lab about requirements-driven complexity, single-team incident ownership and bounded recovery.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Case Lab Assessment first

Offline Authority Has a Boundary

An untimed formative Case Lab about offline ownership within delegated ranges, meaningful local acknowledgment and conditional device-loss recovery.

  • 7 checkpoints + final application
  • Untimed
  • Formative only

Included in the full interview path.

Decision formats

Practice the ways interview tradeoffs are tested.

Each scenario asks you to rank architecture choices against explicit constraints, either as one strongest decision or a set of decisions that must work together.

Single answer

Choose the strongest design under the stated constraints.

Multi-answer

Identify the decisions that must work together to satisfy the scenario.

Content integrity

Original scenarios, aligned to system design decision areas.

CramHQ helps you practice defensible architecture decisions across realistic interview constraints and failure modes.

Decision practiceOriginal scenarios

Original system design scenarios aligned to core decision areas.

Coverage sourceDecision coverage

Coverage is checked across requirements, scale, data, correctness, reliability, operations, and system evolution.

Learning goalDefensible judgment

Built by CramHQ for system design interview preparation.

Quick answers

System design interview practice, answered.

Do I need to sign up?

No. You can start the assessment and review your report before creating an account. Sign up when you want to save the report and continue the Pass Plan.

Is the report free?

Yes. The assessment, Readiness Report, and first targeted repair preview are free.

What does the assessment test?

It tests architectural judgment across requirements, scale, data, reliability, correctness, performance, observability, security, cost, and system evolution.

What is included in the full path?

The full path includes the complete Pass Plan, targeted remediation, 16 topic-based Decision Drills, and the System Design Readiness Exam.

Does this teach one fixed architecture?

No. The questions focus on choosing defensible tradeoffs from the scenario constraints and explaining why nearby alternatives fail.