A · Professional problem solving and implementation
System design
Clarifying requirements and constraints, shaping components, weighing capacity and failure.
Classification boundary
Include: Include questions that design components, data flows, capacity, and failure behavior under constraints.
Choose a neighboring leaf when: Use coding for implementation and quality/security for test strategy, security controls, and reliability gates.
This capability may appear in standards across different stages. Explore stage expectations
74 questions
Choose a group based on the evidence you need. Groups follow existing question formats, not difficulty or mandatory prerequisites. Each batch has up to eight questions.
Concepts and boundaries1
Check concepts, assumptions, and conditions of use.
Questions 1–1
No questions in this section match your target. ·
Judgment and options72
Compare goals, constraints, options, and trade-offs.
Questions 1–8
- A user updates account settings and refreshes immediately, but a read replica returns the old value. Reading from the primary adds load, while waiting for replication may time out. How would you design the experience?
- A new field must be backfilled across hundreds of millions of rows. The first run increases lock waits and replication lag. How would you decide whether to pause, batch, throttle, or use an online migration?
- After reads move to replicas, users sometimes cannot see a change immediately after a successful write. How would you define and handle stale reads?
- Producer logs show an event published and the broker acknowledged it. The consumer has no visible error, but the business object did not change. How would you distinguish acknowledgment semantics, dead letters, filters, deserialization, and duplicate handling?
- A request calls four downstream services, each using a full two-second timeout. End-to-end tail latency is high, and clients continue work after the response is no longer useful. How would you propagate deadlines and budgets?
- Overall capacity is sufficient after sharding, but a few tenants still overload hot keys. How would you reassess the partition strategy?
- Two services write directly to the same business table, and an immediate shutdown is impossible. How would you gradually establish a single data owner?
- An order is updated successfully, but a cross-service report reflects it minutes later. The product asks for “real-time status.” How would you define and implement consistency expectations?
No questions in this section match your target. ·
Questions 9–16
- A cross-service flow includes payment, inventory reservation, and shipment. How would you define compensations and irreversible boundaries when later steps fail?
- Incidents recur at service boundaries. Each team can show its service is healthy, but nobody owns end-to-end recovery. How would you repair accountability?
- Several services have separate owning teams, yet a small change often requires three or four teams to release together. How would you assess whether the service boundaries have failed?
- A new feature adds startup dependencies and cold start becomes much slower on low-end devices, while high-end metrics remain normal. How would you prioritize optimization?
- A user edits offline and queues several changes. When connectivity returns, the token has expired and some requests may already have reached the server. How would you design reauthentication, idempotency, and conflict handling?
- The system uses pre-signed URLs for private downloads, but links can be forwarded or retained for a long time. How would you design authorization and expiry boundaries?
- How should the permission system of a large operations back office be designed? How do you organize roles, data scope, approvals, and audit, and how do you keep it from getting out of control as permissions multiply?
- How would you design an article editing and publishing system? How should state and data be organized for drafts, review, scheduled publishing, multi-channel distribution, and edits after publication?
No questions in this section match your target. ·
Questions 17–24
- Issuing a coupon after payment used to run synchronously, and it is being changed to an async queue with retries. Review this change: which failure sequences worry you most, and what would you rehearse before release?
- How would you design an online audio or video editor? How should the timeline, assets, non-destructive editing, preview, and final export each be designed?
- How would you design a platform where operations staff build campaigns and game mechanics themselves? How do you abstract campaigns, mechanics, rules, and features into configurable parts, and how do you keep a configuration correct once it goes live?
- How would you design a document system for real-time multi-user editing? When several people edit the same passage at once, how do you guarantee eventual consistency, and how do you merge after offline edits?
- From an engineering view, how do you estimate the overall cost of a system? How are storage and compute costs each calculated, and which grow linearly with scale and which do not?
- When the business operates across several countries and regions and user data must flow across borders, how do you solve data compliance in systems and processes, and how do you judge and decide in gray areas where the rules are unclear?
- The local database has updated, but syncing the cache or sending a downstream message fails. How would you make the systems converge and handle retries, compensation, or manual recovery?
- A major promotion or international launch may increase traffic fivefold next year. Starting from the current architecture, how would you check for bottlenecks in the gateway, critical request flows, storage, and machine resources? How would you phase the work, staff it, and validate your assumptions?
No questions in this section match your target. ·
Questions 25–32
- How would you design a product where a person and an AI write together? How are the AI's edits shown, accepted, or rejected, and how are conflicts handled when both edit at once?
- How would you design an immersive audio and video feed so that swiping up and down has almost no waiting? How do you balance preloading, player reuse, memory, and data?
- Design a collaboration product that supports large-file uploads with resumability, where files must be validated and scanned before other members can access them. What constraints would you clarify, and how would you design upload, temporary storage, scanning, publication, permissions, and cleanup boundaries?
- How would you design a large-model chat system? How do you handle streamed output, multi-turn context, history, interruption, and retries, and how do you control cost and latency?
- How do the costs of a recommender system add up, including retrieval, ranking, feature serving, storage, and experimentation? How would you trade effect against cost?
- How would you design an invitation-based viral marketing campaign? How do you design invitation relationships, reward payout, abuse prevention, and effect evaluation?
- To build an online editor like Doc, PPT, or PS, how do you design the core data model and rendering? How do you handle undo and redo, selection, and performance on large files?
- How would you design a real-time risk control system? How do rules, features, models, and manual review work together, and how do you trade false blocks against misses?
No questions in this section match your target. ·
Questions 33–40
- How would you design a search system? How do indexing, retrieval, and ranking divide the work, how are Chinese segmentation and features built, and how do you judge how good the search is?
- How should the loading and request strategy of streaming media be designed so it starts fast and does not stall? How do you trade off segmenting, adaptive bitrate, preloading, and caching?
- Tell me about a project you worked on. Why did you choose that technical approach over the others, how was the decision made, and what were its pros and cons?
- How should coupons, discounts, and flash sales integrate with a trading system without slowing the core transaction flow? How would you calculate, combine, and reconcile discounts?
- An admin console must retain operation records that cannot be casually altered, support queries by actor and object, and handle years of growth. How would you design writes, indexes, and retention?
- Consumers are slower than producers, so the message queue keeps growing while upstream requests still succeed. Where would you apply backpressure, and how would you protect recovery capacity?
- A payment-creation API must support safe client retries. How would you define the idempotency-key scope, retention period, and conflict behavior to avoid duplicate charges without suppressing valid requests?
- After writing an order to a database, a service must publish an event downstream; the process may crash at either step. How would you design durable publication and handle duplicates and ordering?
No questions in this section match your target. ·
Questions 41–48
- In an admin console, inserts and deletes while paging by creation time cause duplicate or missing rows. How would you compare offset and cursor pagination and define the consistency expectation?
- An API runs across multiple instances, and a local request limiter makes the total allowance grow with each instance. How would you design request-rate controls for bursts, accuracy, and failures, and where would you keep their state?
- A user opens a protected order-detail page from an external link. How would you design route parsing, login return, and authorization so the deep link cannot bypass in-app controls?
- Design a service that lets several product teams submit tasks to run after a specified time; tasks may be canceled, rescheduled, or submitted more than once. How would you divide the data model and execution components?
- Several services read feature flags and audience rules on request paths. How would you design the control plane and local evaluation so behavior remains predictable when the control service fails?
- After adding authentication, logging, and error-handling middleware, some failures lack trace IDs and unauthorized requests still trigger expensive parsing. How would you analyze pipeline order and boundaries?
- A high-traffic service must move a critical table to a new model without pausing reads or writes. How would you organize the migration stages and verify a safe cutover?
- A collaborative tool shows who is online and where they are editing. Brief delay is acceptable, but disconnected members must not remain online indefinitely. How would you design updates and expiry?
No questions in this section match your target. ·
Questions 49–56
- A product needs to send transactional and optional marketing notifications to tens of millions of users, who can change channel preferences at any time. How would you design the sending process?
- A global service must enable different features and retention rules by region while headquarters still needs an overall operational view. How would you divide configuration, enforcement, and aggregation?
- A search service must change tokenization and ranking features without long result gaps or a major increase in write latency. How would you evolve the index?
- A subscription product includes trials, renewals, grace periods, refunds, and family sharing. How would you design entitlement checks so several services receive consistent, traceable results?
- A usage-based API product must combine request events from multiple regions into customer bills and allow later corrections. How would you design the usage-data processing flow?
- A multi-tenant platform must send event notifications (webhooks) to customer systems. How would you design delivery and retries when a client is unavailable for a long time?
- Several tenants share an asynchronous job platform, and some submit many long-running tasks. How would you design scheduling, isolation, quotas, and use logs, metrics, and call records to understand queue behavior?
- Some objects become hot, degrading reads while writes must remain ordered. How would you divide caching, partitioning, and write coordination?
No questions in this section match your target. ·
Questions 57–64
- The business needs every state change to be traceable and safely replayable, but some old events lack fields. How would you design event versions, retention, and replay boundaries?
- A multi-region service must preserve critical functions during a regional outage, but some data cannot tolerate conflicting overwrites. How would you choose degradation, replication, and recovery policies?
- A real-time collaboration service has many long-lived connections, and slow clients accumulate updates. How would you choose between dropping, combining, limiting updates to slow clients, and resynchronizing?
- Different teams own creation, editing, and review, and their form feedback is becoming inconsistent. How would you decide which patterns to standardize and which to keep distinct? How would you check loading, empty, error, and recovery states?
- Users can edit a profile on a phone while offline and may also edit it on the web. The device must sync when connectivity returns without silently overwriting valuable changes. How would you design versioning, conflict detection, merging, and user confirmation?
- An entry service calls several downstream systems. One noncritical dependency occasionally slows down, exhausting request threads and affecting unrelated features. How would you design timeouts, concurrency isolation, degradation, and recovery?
- A mobile upload of a large file may be interrupted, and users may retry by tapping again; the system also bills successful processing. How would you design chunks, validation, resumable state, finalization, and the billing point?
- A business-rule correction requires recalculating historical records across several services, but some consumers have already sent notifications or performed external actions. How would you design correction events, impact lists, replay boundaries, and side-effect suppression?
No questions in this section match your target. ·
Questions 65–72
- After a dependency slows down, several callers increase retries at the same time; traffic doubles and the outage spreads. How would you design retry budgets, backoff, jitter, and cross-service coordination?
- A live index needs a new shard key as data grows quickly and writes cannot stop. How would you plan old and new indexes and decide when to cut over?
- A multi-tenant query platform shares a database pool. One tenant submits many complex reports and increases latency for others. How would you isolate and meter usage?
- An admin API can change customer states in bulk. A script began calling it directly and caused broad changes. How would you redesign authorization and safeguards?
- A user starts a large export and disconnects; access is revoked while the job runs. The job needs resumability without leaking data after revocation. How would you design it?
- Product data lives in application, CDN, and client caches. After a price update, users see different values. How would you define refresh, versioning, and invalidation semantics?
- A live dashboard uses event-time windows, while finance groups by settlement time and excludes unsettled transactions. A leader believes one report must be wrong. How would you explain and govern this?
- Every read request is logged, driving cost up, while compliance requires evidence for sensitive actions. How would you tier collection and retention?
No questions in this section match your target. ·
Implementation and verification1
Examine execution, verification, and correction.
Questions 1–1
No questions in this section match your target. ·
No questions in this capability match your target. ·