TOPIC
Reliability
These are the same questions found in the library, grouped here by the capability each one mainly examines.
129 questions
Questions 1–50 of 129 on this page.
A · Professional problem solving and implementation46
- 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 document assistant can submit most cases automatically, but mistakes have very different consequences. Human review has reduced errors, but the queue keeps growing. How would you decide which cases to automate or review, and keep the queue within the team’s capacity?
- After a foundation-model change, the average score improves, but outcomes worsen for a few important customers. How would you decide whether to ship, stage, or roll back?
- Enterprise knowledge documents may change, be withdrawn, or become restricted, yet users still receive answers citing old content. How would you propagate changes from source documents through chunks, indexes, caches, and existing citations, and prove that an update or deletion took effect?
- Production answers contain incorrect citations or degrade in quality, but prompts and retrieval context may include sensitive data and cannot be logged by default. What telemetry would help distinguish retrieval, model, and tool failures while controlling data exposure?
- A RAG assistant cites an internal document, but its owner has updated the process and the new version is not indexed yet. How would you define freshness goals, propagation, and answer behavior during the gap?
- 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 very large CSV must be validated without loading the whole file into memory. On malformed rows, the tool should report line numbers and continue checking. How would you design the parser interface?
- A long-running process keeps using more memory, while object counts in heap snapshots fluctuate. How would you use evidence to distinguish a true leak, intentional cache retention, fragmentation, or growth in native memory?
- 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?
- A new index speeds up queries, but write latency and storage growth worsen noticeably. How would you decide whether to keep it?
- 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?
- In production the same order is occasionally submitted twice, and you cannot reproduce it locally. How would you narrow it down, and would you stop the bleeding first or add observability first?
- A cache key is invalidated and logs show a database reread, yet some users still see old data. Switching to the primary helps but does not eliminate it. How would you investigate caches, replicas, and clients?
- 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?
- On-call engineers receive many alerts each day, yet user complaints and service objective violations still go unnoticed. How would you redesign alerting?
- Cloud costs keep rising and finance asks for cuts while teams are improving reliability. How would you find savings without shifting risk elsewhere?
- A long-lived credential is shared by several services. Security requires prompt rotation, but all dependents cannot be stopped at once. How would you proceed?
- Some production resources differ from their declared configuration, including undocumented emergency fixes. How would you distinguish intentional changes from unexplained differences, assess the risk of overwriting state, restore trust, and prevent recurrence?
- A release must reach thousands of runtime nodes with varying versions and network conditions. How would you design rollout batches, health checks, and pause criteria?
- After a release goes wrong, the team says “we can roll back.” How would you check that this is true and not just a line in the plan?
- The application can be rolled back, but a database migration removed an old field and the previous version can no longer start. How would you redesign release order and rollback?
- You take over a module that is about to ship and has very low test coverage, and time is short. How do you decide which tests to add first, and how do you explain that order to the team?
- 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 critical user journey across several pages and services regresses often. How would you define the scope and priority of automated tests?
- Service failures have exceeded the target range, but the business has firm feature commitments. How would you adjust the release pace and investment in reliability?
- Backups report success, but the team has never verified restored data integrity or recovery time. How would you establish demonstrable recovery capability?
- 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?
- 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?
- After replacing a foundation model, overall metrics remain similar but some users report worse results. How would you identify what changed in model behavior and decide whether to roll back?
- When the model cannot establish an answer, should the product refuse, return a low-confidence result, or escalate to a person? What distinguishes the choices?
- A build registry must clean up years of images, but production services may still roll back to old versions. How would you define retention and artifact recoverability?
- API latency rises while database CPU remains low, and application logs show connection waits. How would you distinguish connection leaks, an undersized pool, and slow transactions holding connections?
- A client must upload a large file, but the operating system may pause or terminate background work at any time. How would you chunk the task, persist progress, and make rescheduling safe?
- After a database field change, only some downstream jobs fail intermittently. How would you identify consumers still using the old contract and decide between rollback and a compatibility fix?
- Monthly aggregates initially match detail reports, but the gap grows over several weeks. How would you narrow the cause among definition changes, late data, duplicate processing, and historical backfills?
- 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?
- Message backlog often falls after scaling out, then returns a few hours later. What producer, consumer, and message characteristics would you inspect to locate the actual bottleneck?
- 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?
- 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 defect appears only in production and cannot be reproduced in development or staging. How would you determine whether the cause is environment, traffic shape, or data characteristics, and improve environment design?
- 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?
- A critical end-to-end test fails intermittently: it passes alone but fails in a parallel suite, and the team has started rerunning it until it passes. How would you determine whether it exposes product risk, isolate shared state, resource contention, clock or ordering dependencies, and improve the test workflow?
No questions in this section match your target. ·
B · Business understanding and domain modeling4
- A quality check occasionally produces false alarms and blocks downstream jobs; removing it once let bad data reach settlement. How would you design tiered handling?
- Duplicate registration created two customer entities later confirmed to be the same company. Reports should unify them, while contracts, approvals, permissions, and personal actions must retain original responsibility. How would you model the merge?
- A business rule is corrected retroactively. Reports need corrected results, while decision-makers also need the results available at the time. How would you manage both historical views?
- A producer adds an order status, and an old consumer rejects the whole message because enum validation is strict. Teams disagree over who must update, and consumers have different owners. How would you design compatibility and rollout order?
No questions in this section match your target. ·