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 351–400 of 931 on this page.
A · Professional problem solving and implementation24
- The input contains time intervals that may overlap or touch, and callers need to find records covering a given instant. Describe or implement a merge and query strategy, including whether endpoints are inclusive.
- An API adds a new state, but older clients may not recognize it; some must still display the record, while critical operations must reject unknown states. How would you design parsing and defaults so an unknown value is not mistaken for a valid state?
- A streaming service deduplicates events using persistent state and checkpoints. After restoring a checkpoint, the stream may replay events; a crash can also occur between saving the deduplication state and committing the stream offset. How would you make rollback and replay safe while keeping memory bounded?
- The client sees one submission, but the server occasionally creates two identical records. It usually happens after a timeout and retry, with no obvious log error. How would you reconstruct the request timeline and verify where duplication occurs?
- 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 feature is fully launched, but switches created years ago still control several code paths; the team does not know which flags can be removed and relies on memory during rollback. How would you establish flag lifecycles and cleanup ownership?
- Teams can release micro-frontend modules independently, but loading, navigation, error messages, and accessibility behavior are becoming inconsistent. How would you decide which capabilities belong to the platform and which stay with product teams?
- A backend API generates TypeScript, Java, and Swift SDKs, but nullable types, enums, and error models are drifting across languages. How would you design the contract source, generation process, and cross-language compatibility tests?
- A production dependency has a different artifact hash from the build associated with its repository tag, and the team cannot confirm it passed the expected CI. How would you establish build traceability, artifact verification, and release authorization?
- New clients use a replacement API, but users upgrade slowly and older versions still account for meaningful traffic; continued support also constrains server evolution. How would you set a support window, capability detection, migration notices, and retirement criteria?
- 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?
- An analytics assistant converts natural language into SQL against business data; a request may induce it to read sensitive columns or run an expensive query. How would you design read-only permissions, query validation, resource limits, and result redaction?
- A model begins returning structured JSON, while mobile, server, and analytics consumers upgrade at different rates; new fields may be absent or enum values may change. How would you define the output contract, handle validation failures, and preserve compatibility?
- An AI assistant reads user-uploaded documents that may tell it to ignore existing rules and call external tools. How would you distinguish data from instructions, constrain tool permissions, and verify the safeguards?
- 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?
- Overall task success is unchanged after a model update, but outcomes diverge more across users by language, device, and experience. How would you define evaluation segments, manage small-sample risk, and decide whether to continue rollout?
- The team believes a new flow is simpler, but usability tests show only familiar users succeed; newcomers get stuck on permission explanations and next steps. How would you recruit, design tasks, and define observations to judge whether it is actually usable?
- Researchers can recruit only active users but need to understand why occasional or churned users leave. How would you identify sample bias, adjust recruitment, and limit the reach of conclusions?
- 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?
- The team needs real user conversations to reproduce model failures, but logs contain personal and sensitive business content. How would you minimize collection, redact data, authorize access, and set retention while preserving debugging value?
No questions in this section match your target. ·
B · Business understanding and domain modeling26
- Marketplace transactions keep growing, but buyers wait longer, sellers cancel more often, and subsidy spending rises. How would you describe the exchange of value and constraints across participants, then decide whether growth reflects better matching or one-sided subsidy?
- An order moves through created, awaiting confirmation, processing, partially fulfilled, canceled, and refunded states; different pages and services interpret “complete” differently. How would you model state, events, and valid transitions so each client does not invent its own meaning?
- A user upgrades mid-cycle and later requests a refund. The contract requires a calculation based on remaining service time, while promotional discounts and taxes also affect settlement. How would you decompose the rules and make the amount calculation traceable?
- A campaign allows each user to claim a discount once, but under high concurrency a user submits from multiple devices and receives several entitlements. How would you map the eligibility rule to atomic reservation, issuance records, and failure compensation?
- A user clicks a campaign link on Monday and purchases on Tuesday, but the purchase event uploads on Friday because the client was offline. How would you define event time, arrival time, attribution windows, and backfill rules so results remain explainable?
- A database field has been replaced, but reports, exports, and external integrations still read it; deleting it directly could cause silent errors. How would you plan compatibility migration, consumer confirmation, and final removal?
- Marketplace order value is rising, but merchants receive lower settlement amounts; the gap may involve discount sponsors, refunds, platform fees, and settlement timing. How would you explain participant value, money flows, and operating constraints along the transaction chain?
- Sales reports growth by signed contract value, Finance tracks recognized revenue, and Operations schedules work by fulfilled orders; all three call their number “business scale.” How would you map the process and definitions so teams can make one decision together?
- Enterprise customers expect a weekday response, while individual users expect self-service at any time; the team plans to standardize one support workflow. How would you analyze customer needs, issue urgency, service commitments, and delivery costs?
- An enterprise customer uses one contract for several departments; employees may work across departments, and administrators may operate on behalf of multiple accounts. How would you distinguish organizations, contract accounts, individual identities, memberships, and authorization scope?
- A cross-team project launches on schedule, but user feedback, operating costs, and data corrections remain; the project team is about to disband. How would you model product, platform, operations, and project responsibilities after delivery?
- A product feature is configured by customer contract, adjusted by experiment group, and constrained by regional rules; analysts need to explain which combination shaped a user's experience. How would you model configuration sources, scope, effective time, and decision provenance?
- Customers pay by API usage, but usage events may be duplicated, arrive late, or be replayed at month-end; sent invoices can lead to disputes. How would you define billable units, deduplication keys, close windows, and corrections?
- A dashboard's total conversion rate cannot explain which customer segment or process step caused a change; teams want to drill down by channel, plan, and region, but dimensions have different grains. How would you define fact grain and valid aggregation rules?
- A promotion increases subscriptions, but many subscribers renew at a lower price and full-price renewal has not yet reached its observation window. How would you decompose acquisition, renewal, discount, and churn to judge long-term value?
- A user reports that a service was not fulfilled as promised. Logs show the product flow triggered, the supplier did not confirm, and Operations says the contract is unclear. How would you map the service commitment, ownership boundaries, and remediation path?
- The company shifts from acquiring new customers to increasing value from existing customers, but sales incentives, product roadmaps, and service capacity still reflect acquisition goals. How would you map the value chain and incentives to find misalignment?
- A plan includes entitlements, users can purchase add-on capacity or receive temporary campaign credits, and contract changes may require manual compensation. How would you distinguish entitlement definitions, granted balances, sources, expiry, and consumption records?
- A cross-team objective spans several projects, each with routine tasks, risks, and incidents; retrospectives struggle to trace which decisions and work drove an outcome. How would you model relationships among objectives, projects, work items, events, and evidence?
- Business users can edit rules ahead of time, schedule them after approval, and still have older versions referenced by some users and asynchronous jobs. How would you model draft, review, publication, effective time, and rollback?
- Order revenue is shared by a platform, provider, and channel partner. Weeks later, part of the order is refunded; one party has already settled and lacks sufficient balance. How would you express allocation rules, refund responsibility, recovery, and reconciliation state?
- A product offers one free trial, but users may register with another email, share a device with family, or qualify through a partner channel. How would you define the eligible party, exception sources, abuse boundaries, and appeals?
- Business reporting needs the duration of every state transition, while an operations page needs only the object's current state; a wide table overwrote history during updates. How would you separate event facts, snapshots, and current-state models?
- CRM, billing, and product logs use customer IDs, contract IDs, and anonymous device identifiers; analysts need one customer's lifecycle. How would you model identity mappings, confidence, temporal validity, and correction?
- Several teams maintain customer profiles. When data is wrong, no one knows which system is authoritative, and systems also write values back to one another. How would you define field ownership, source of truth, synchronization direction, and dispute handling?
- A device reports a cumulative counter, but the counter resets after device replacement or data correction; the data platform may also backfill historical events. How would you define deltas, reset markers, negative differences, and recomputation boundaries?
No questions in this section match your target. ·