TOPIC
Reliability
These are the same questions found in the library, grouped here by the capability each one mainly examines.
129 questions
Questions 51–100 of 129 on this page.
A · Professional problem solving and implementation31
- After an update, some users occasionally load new HTML with old JavaScript and the page fails. How would you design asset naming, cache policies, and release order to reduce inconsistency?
- A request starts several async tasks. After the client disconnects or the request times out, some downstream work still uses threads and connections. How would you propagate cancellation and release those resources?
- 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?
- During a cross-time-zone handoff, a critical alert was sent. The outgoing on-call engineer assumed the incoming engineer would handle it, while the incoming engineer never acknowledged it; escalation was delayed. How would you reconstruct the ownership chain, fix acknowledgment and handoff, and verify the change?
- 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 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 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 changing an embedding model, old and new vectors are not directly comparable, while a full rebuild takes days. How would you design migration and query cutover?
- A team discovers that a model may have seen some internal evaluation prompts in public corpora or fine-tuning data. How would you determine what offline scores still mean and rebuild a trustworthy evaluation?
- A new model improves offline evaluation, but answer quality may fall for a small set of high-value users. How would you stage a canary, observe it, and decide when to expand traffic?
- A product depends on an external model API, and the provider may restrict request frequency or change available models. How would you design switch rules and temporary shutdowns for noncritical features so quality changes after switching are visible?
- 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?
- At peak load, the entry service records a request but downstream events are missing, while retries amplify traffic. How would you trace the request through each service to locate loss and duplication?
- 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?
- Latency is normal after a release, but p99 rises gradually after several hours and temporarily recovers after a restart. CPU is steady while connection counts and heap memory slowly grow. How would you break down hypotheses and design low-risk tests?
- 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?
- An AI assistant repeatedly calls search, databases, and external APIs for a small share of requests, making latency and cost far higher than average. How would you design per-task budgets, stop conditions, idempotency, and auditable execution records?
- A core service remains within its monthly SLO, but its error budget is being consumed much faster and errors cluster around a recent feature release. How would you decide whether to pause rollout or roll back?
- A model service used by an AI feature has highly variable latency, causing user requests to exceed the end-to-end deadline. How would you allocate budgets across retrieval, model calls, and post-processing, and design fallbacks after a timeout?
- The default locale renders correctly, but a few buttons overflow and tables shift after switching languages; failures occur only on narrow screens with enlarged system text. How would you narrow the cause and build regression coverage?
- Fresh installations work, but users who upgraded across several versions report missing local drafts. The issue is hard to reproduce, and the server has no corresponding deletion record. How would you preserve evidence and investigate migrations, cache cleanup, and lifecycle callbacks?
- 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?
- 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 user submits a long AI analysis, closes the page, and later checks from another device; the task may call several tools and produce partial results. How would you design task state, cancellation, retry, and result visibility?
- A model has streamed partial output to a user when the connection drops or a safety check fails; the client may make the answer look complete. How would you design completion markers, withdrawal or explanatory notices, and retry behavior?
- Users can upload archives for processing, and a past incident showed that malicious files could exhaust resources or access paths without authorization. How would you design isolation, extraction limits, content checks, and safe failure behavior?
No questions in this section match your target. ·
B · Business understanding and domain modeling1
C · Value judgment and direction setting1
D · Delivery and ongoing operations15
- A data-write incident has stopped and service metrics look normal, but users still report missing records. How would you organize recovery validation and follow-up communication?
- When a payment-risk dependency slows, checkout times out. The business wants to preserve conversion without bypassing critical safety checks. How would you decide which checkout functions can be temporarily disabled and which checks must remain?
- Incidents and recovery work interrupt every iteration, and roadmap commitments keep slipping. Leadership wants the dates preserved without adding staff. How would you propose capacity and goal changes?
- A campaign goes live overnight, but heavy traffic stalls the system. Users cannot claim coupons and start complaining. As an engineer involved in the campaign, how would you coordinate with operations and support on temporary business measures while restoring the system?
- A system keeps having problems again and again, and each fix is followed by another failure. How do you find the root cause, how do you move the team from firefighting to real repair, and how do you show it no longer recurs?
- A production service suddenly fails widely. In what order do you act during the first hour?
- A major incident produces 18 actions across architecture, monitoring, training, and process, but teams already have quarterly commitments. How would you select actions that reduce recurrence risk?
- How do you keep the same kind of personal mistake from happening again? Did you improve the process and tooling, or just remind yourself to be careful? How do you know the improvement works?
- During an outage, engineering wants to disable a feature, business wants to keep accepting orders, and support has promised a recovery time. Responders receive conflicting directions. How would you organize the response?
- A critical operations playbook is still used by multiple regions, but its author has left and recent system and policy changes were never incorporated. How would you identify which steps remain safe, establish temporary controls and ownership, and verify that frontline teams can use the new version correctly?
- An automated approval service stops working, so the operations team temporarily switches to a spreadsheet and limits user impact. Two weeks later, the service is still down, and the spreadsheet has inconsistent permissions and records. How would you manage the temporary process, restore automated approvals, and decide when to shut it down?
- A mobile release goes to 5% of users. The crash rate appears to double, but active devices are few and mostly one older model; a marketing campaign is near. How would you limit harm, gather evidence, and decide whether to continue, pause, or roll back?
- An incident is resolved, and the review lists more than ten actions for monitoring, capacity checks, and documentation; earlier actions were never verified. How would you assign owners and dates and confirm whether improvements worked?
- After a mobile release, network failures rise while server metrics remain normal; affected users cluster on older OS versions and weak connections. How would you scope the incident, reduce impact, and decide whether to pause or roll back?
- A core service is partially unavailable and the cause is unknown; customers, executives, and partners request updates, while the team worries that early communication could mislead. How would you separate known facts, hypotheses, actions, and the next update time?
No questions in this section match your target. ·
E · Collaboration, communication, and influence1
No questions in this section match your target. ·