USE CASE
Designing as an interviewer
These are the same questions found in the library, grouped here by the capability each one mainly examines.
994 questions
Questions 1–50 of 994 on this page.
A · Professional problem solving and implementation50
- 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?
- Two reviewers often disagree about the same set of AI outputs. How would you tell whether the issue is annotator disagreement, an unclear evaluation standard, or model instability?
- 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?
- A generative feature produces good answers, but peak latency and per-request cost exceed the product budget. How would you determine whether the cause is the model, context, retrieval, or call chain?
- 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?
- Your company wants an internal knowledge assistant, and document permissions change as people move around. How would you make it answer with evidence while keeping it from exposing what a user should not see?
- User satisfaction with a knowledge assistant has fallen, but offline retrieval metrics are unchanged. Which parts of the system would you investigate?
- You ask an AI to review a configuration or generate a piece of code. How do you decide whether it can go live?
- 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 new model raises overall accuracy from 91% to 94%, but errors remain concentrated in cases that affect customer rights. The team wants to ship based on the aggregate score. How would you decide?
- 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 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?
- When writing code and reviewing it, what checks have become habit for avoiding performance problems such as querying a database inside a loop or holding large objects too long? How do you know they actually work?
- Implement a retry wrapper that retries by error type, supports a maximum attempt count, backoff, and cancellation, and does not overwhelm the dependency. Define the interface before coding, then explain how to make clocks, waits, and tests deterministic.
- 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?
- After multiple macro and code-generation expansions, compiler errors point only to generated files, leaving users unable to find the original code. How would you design diagnostics?
- Incremental compilation is fast, but changes to a shared header sometimes fail to rebuild all dependent targets. How would you find the dependency-tracking gap?
- A compiler upgrade changes struct layout or calling conventions, but some plugins are still built against the old ABI. How would you manage compatibility and migration?
- 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?
- 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?
- 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?
- Overall capacity is sufficient after sharding, but a few tenants still overload hot keys. How would you reassess the partition strategy?
- On-call engineers receive many alerts each day, yet user complaints and service objective violations still go unnoticed. How would you redesign alerting?
- An old system keeps accumulating new business and is becoming hard to maintain. How would you create an adapter boundary between old and new systems so legacy rules and data models do not spread into new code? Explain the migration steps and any compromises or risks you would accept.
- Tell me about an architecture upgrade. Why did it have to be upgraded rather than patched further, what challenges came up during migration, how did you keep the business running, and did the benefit materialize?
- For a given capability, how do you decide between building it, adopting open source, or buying it? How do building and open source differ in cost, control, maintenance, and risk, and when should you switch from one to the other?
- A repository accepts external contributions, and CI runs build scripts, reuses caches, reads test credentials, and produces release artifacts. How would you separate untrusted execution, credential permissions, and cache boundaries so code cannot read secrets or poison trusted artifacts?
- 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?
- How do you identify and record technical debt and pay it down without stopping business delivery? Which debts are worth paying and which can be left for good, and how do you judge?
- The root cause of an incident is still unknown, but business stakeholders ask when service will recover. How would you update them, communicate uncertainty, and avoid misleading commitments?
- 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?
- A company’s frontend projects live in separate repositories, and someone proposes merging them into a monorepo. How would you decide whether to do it, and how would you validate it in steps?
- 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?
- The framework allows concurrent background UI updates, but a slow response occasionally overwrites a newer selection. How would you design concurrent state updates?
- A complex form has field validation, cross-field rules, and server errors that overwrite one another during edits. How would you divide framework state from business state?
- Several pages share server data and framework caching reduces requests, but stale results appear after users switch accounts. How would you design cache keys and invalidation boundaries?
- After a frontend framework upgrade, compilation succeeds, but render timing, default caching, or side-effect order changes. How would you verify product behavior remains correct?
- A user signs in within one child app but loses permissions or session state when switching to another. How would you design the boundary for shared auth context?
- One app emits an “order completed” event, but other modules interpret it differently, causing duplicate requests and divergent page state. How would you define a cross-app event contract?
- Users report a blank page after navigating across apps, while each team’s monitoring appears healthy. How would you establish end-to-end observability?
No questions in this section match your target. ·