TOPIC
Distributed systems
These are the same questions found in the library, grouped here by the capability each one mainly examines.
55 questions
Questions 1–50 of 55 on this page.
A · Professional problem solving and implementation47
- An AI assistant can create tickets, issue refunds, or change accounts on a user's behalf. A refund request times out, and the system cannot tell whether it completed; retrying may issue a second refund. How would you check the outcome, control retries, and ensure actions stay within the user's authorization?
- A multi-step agent reads project permissions at startup. Before step three, the user is removed from the project, but the task still holds a tool token. How would you design authorization checks and cancellation semantics?
- 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 cache can make reads faster and can also show users stale content. How do you decide whether a piece of data suits caching, and how do you notice when it goes wrong?
- After reads move to replicas, users sometimes cannot see a change immediately after a successful write. How would you define and handle stale reads?
- After cache expiry, many requests hit the origin at once, and recovery causes a second traffic spike. How would you diagnose and suppress a cache stampede and warm-up storm?
- 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?
- 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 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?
- 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?
- Before drawing any architecture diagram, which few numbers would you use to decide whether a service should be split or cached? Use a service you know to explain.
- 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?
- 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?
- 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?
- 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 reconciliation shows timestamps from two data centers placing event A before B, while the message trace shows B triggered A. How would you distinguish clock skew, processing delay, and business causality, and choose trustworthy diagnostic evidence?
- A critical dependency intermittently times out in one region while overall health checks remain green. How would you assess impact and isolate or degrade it safely?
- Average service latency is stable, but p99 has risen for a week and complaints cluster among a few large customers. How would you locate the problem and choose what to verify first?
- 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?
- A service has moved to a new address, but some users still reach old nodes and recovery varies by network. How would you check DNS caches, client caches, and existing connections?
- 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?
- 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 service’s resident memory is stable, but major page faults, disk I/O, and tail latency rise together. How would you distinguish changes in the working set, mapping behavior, memory pressure, and application access patterns?
- 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?
- After a downstream service becomes unstable, upstream traffic appears flat while request counts and queue depth double and several services time out. How would you determine whether retries are amplifying the failure?
- 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?
- After deployment on a multi-socket machine, threads move across NUMA nodes and memory latency varies. How would you investigate using CPU affinity, memory placement, and scheduling behavior?
- After certificate rotation, short connections work, but some clients fail a handshake when reconnecting or resuming after a long-lived connection closes. How would you distinguish certificate-chain, resumption, connection-pool, and client-cache effects?
- When a mobile device switches from Wi-Fi to cellular, some HTTP/3 requests fail while the session still appears online. How would you investigate path migration, timeouts, and middlebox behavior?
- A program writes a data file before updating its index, but after a power loss the index points to incomplete content. How would you analyze write ordering, flush semantics, and recovery?
- Average latency is stable while p99 worsens, with large differences across tenants. How would you narrow the cause to queuing, lock contention, downstream fan-out, or resource isolation?
- 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?
- 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?
- 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?
No questions in this section match your target. ·
B · Business understanding and domain modeling3
- A user asks to have personal data deleted, while finance must retain transaction records for audit. How would you define the boundary among deletion, anonymization, and traceability?
- Business reports mix orders, order lines, and payment attempts, so metrics disagree across pages. How would you establish fact-table grain and validate aggregation semantics?
- The source database has deleted a customer, but a change data capture (CDC) pipeline and downstream summary views still show the old record. How would you trace the deletion event, update dependent views, and verify cleanup?
No questions in this section match your target. ·