USE CASE
Designing as an interviewer
Start with reviewed core questions. The extended library remains available below for broader exploration.
994 questions
Extended library · not reviewed question by question
These questions remain useful for discovery, but have not received the same question-specific review as the core set.
Extended questions 101–150 of 931 on this page.
A · Professional problem solving and implementation18
- A third-party model provider changes its training, retention, or cross-border terms. When should calls pause or receive renewed approval?
- Average AI quality meets the target, but a few high-risk errors can cause harm. How would you set the release gate?
- An AI assistant can call internal tools, but tasks require different permissions. How would you design authorization and audit?
- 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?
- Overall AI accuracy passes, but one language or user segment has a higher error rate. How would you assess and respond?
- 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?
- Two threads use a flag to signal that data is ready. Why might declaring only the flag atomic still fail to guarantee visibility of the data?
- 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?
- 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 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?
- 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 storage service shifts from read-heavy to sustained writes, and the team is comparing B-tree and LSM approaches. Which workload characteristics would guide the choice, and what read/write amplification costs would you examine?
- In a multicore program, two threads update different fields yet performance falls as core count rises. Explain how cache-line sharing could cause this and how you would verify it in code.
- An organization must move several repositories from an old CI system to a new platform without pausing delivery across teams. How would you sequence migration and decide which repositories enter each wave?
- 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?
No questions in this section match your target. ·
B · Business understanding and domain modeling32
- A major customer has a special rate in its contract, but the exception may end at renewal. How would systems and operations avoid keeping the old exception indefinitely?
- A partner prepays credits that expire, and a customer uses or refunds them in several batches around the expiry date. How would you represent credits, consumption, expiry, and refunds in settlement?
- In a system that handles money, how should accounting and billing be designed so the numbers are clear and reconcile? How do you model accounts, entries, holds, settlement, and reconciliation, and how do you trace and correct an error?
- How should amounts, currencies, rounding, and time zones be expressed in a transaction and settlement model? Which practices look fine but break at reconciliation?
- An order may use a membership discount, channel offer, and coupon, with exceptions by product, contract, or region. How would you define eligibility and calculation order so customers see a consistent amount and finance can reconcile refunds?
- The revenue share between a platform and its creators changes in tiers with monthly volume. How would you express this settlement rule so product, engineering, and finance can each verify it independently?
- The business says data must be real time, but no one can explain the cost of a fifteen-minute delay. How would you decide the architecture and freshness target?
- Product, finance, and growth teams each report “active users,” but the numbers differ. What would you ask before deciding whether to standardize the definition?
- Taking concepts such as orders, contracts, and settlements, how are they mapped into the data model? Which concepts were split into several entities, which were merged, and why?
- A user consented to product analytics, then withdrew consent. Derived metrics already reached reports, experiments, and model-training data. How would you model consent state, purpose scope, and propagation?
- A producer plans to rename a field and change an enum’s meaning, while a dozen teams depend on the current schema. How would you manage the change?
- 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?
- A monthly close report was sent to leadership. Days later, a late refund and price correction arrive. The business wants current figures updated, while finance must explain the prior report. How would you model this?
- Mobile events may arrive days late, while reports must reflect event time. How would you model and process late, corrected, and duplicate events?
- Orders, payments, and refunds are often stored in one table. How would you distinguish their business identities, lifecycles, and cardinalities? Compare conditions, costs, and validation for separate models and combined storage.
- A critical dataset is reused by several products and reports, but no one can explain its sources, owners, or sensitive fields. How would you improve governance without blocking current use?
- An account moves from sales to customer success mid-month. Monthly metrics must show the outcome and who owned it at each point. How would you define ownership events and reporting rules?
- A fee rule changes today, but a disputed order was created under the old rule. How would you preserve rule versions and transaction facts so finance can reproduce the original calculation?
- A company buys 100 seats used across subsidiaries. Headquarters signs the contract, but some subsidiaries want separate invoices and permission administrators. How would you distinguish customer, contract, organization, account, member, and seat so access and billing stay consistent?
- Customer master data has separate identifiers and states in CRM, billing, and product systems, so downstream reports disagree. How would you establish explainable sources of truth?
- 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?
- An account may hold a base plan, temporary trial, campaign benefit, and support credit. Systems implement precedence differently, so access sometimes flips. How would you define eligibility and conflict rules?
- A model feature will be retired, but several online models and historical reports still depend on it. How would you plan retirement and replacement?
- An online feature must refresh every second, but it affects few requests and its maintenance cost keeps rising. How would you decide whether to keep it real time?
- A risk model uses later default as its training label, but many transactions have no final outcome before the observation window ends. How would you handle label maturity, sample inclusion, and retrospective evaluation?
- A service changes eligibility from “current account status” to “account status at application time plus a risk-review result.” Support needs to explain historical denials, and audit must reproduce the original decision. How would you evolve rules and data models without conflating old and new outcomes?
- 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 support ticket can be reopened when a customer provides new evidence and may be split into follow-up work. How would you model states and events so closure, reopening, and splitting remain traceable?
- 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?
- Enterprise contracts specify first response, service restoration, and final resolution times, each with different pause conditions. Support tracks one SLA timer, causing disputes. How would you model this?
- Where does your project sit in the wider business? Who gives it input, who uses its results, and who is affected if it is late or wrong?
No questions in this section match your target. ·