USE CASE
External job interviews
Start with reviewed core questions. The extended library remains available below for broader exploration.
1324 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 151–200 of 1229 on this page.
A · Professional problem solving and implementation33
- 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?
- A user opens a protected order-detail page from an external link. How would you design route parsing, login return, and authorization so the deep link cannot bypass in-app controls?
- A list screen scrolls poorly even though network metrics are normal and memory is stable. How would you determine whether main-thread computation, layout/drawing, or lock waits are responsible?
- Implement a map with concurrent reads and writes, per-entry expiration, and expired-entry cleanup. How would you define expiration semantics, synchronization boundaries, and deterministic tests?
- Implement deep equality for inputs that may contain nested arrays, shared references, and cycles. Define equality semantics first, then avoid infinite recursion and accidental confusion of reference structures.
- Implement a small task queue with concurrent workers, cancellation, and retries; tests must not depend on real sleeps. How would you design the scheduling interface and state transitions?
- Implement an incremental UTF-8 log parser that receives chunks which may split multibyte characters, reorder fields, contain multiple records, or include an exceptionally long line. Define parser state, error recovery, and memory limits, then implement repeatable core logic.
- A service increases its worker threads from 16 to 256, but throughput does not improve and CPU use rises. How could context switching contribute, and what evidence would you use to verify it?
- 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?
- A reconciliation shows timestamps from two data centers placing event A before B, while the message trace shows B triggered A. How would you distinguish clock skew, processing delay, and business causality, and choose trustworthy diagnostic evidence?
- 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?
- Design a service that lets several product teams submit tasks to run after a specified time; tasks may be canceled, rescheduled, or submitted more than once. How would you divide the data model and execution components?
- Hundreds of repositories pin different third-party versions, and security teams struggle to identify exposure when a severe vulnerability appears. How would you establish dependency updates and risk handling?
- 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?
- A third-party SDK callback updates data, but the UI does not refresh; forcing a refresh causes duplicate updates. How would you identify the framework’s change-detection boundary and choose the right integration point?
No questions in this section match your target. ·
B · Business understanding and domain modeling17
- 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?
- You are building a 'days active in the last 7 days' feature for a model that predicts next-day churn. How do you define its time semantics so training and online prediction mean the same thing?
- An order has a single status field that means both fulfillment progress and payment result, and several teams read it. How would you split it into two concepts and move old data and old consumers over smoothly?
- 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?
- Map the area you have owned over time: what users are trying to do, where the main process obstacles are, what your module can influence, and what is outside its control.
- Write a one-page product overview for someone who just joined. How would you mark which statements are fact, which are inference, and which are simply unanswered questions?
- 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. ·