DOMAIN A
Professional problem solving and implementation
Whether a person can design, build, and verify a solution with the knowledge of their craft.
See this capability domain in stage expectations. Open the capability model
Choose a capability first. Each preview shows up to three questions; open it for focused batches.
309 questions · 9 capabilities
Computer-science foundations45
Algorithms, operating systems, networks, and databases, and how they explain real behavior.
- 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?
- Two jobs run fine alone but occasionally hang when run together. What conditions must hold for a deadlock, and how would you confirm that is the cause?
- After a page sits idle, the first request is much slower than later ones. What network-level causes could explain it, and how would you tell them apart?
- A query filters on an indexed column and is still slow. Explain how an index lookup works and what can keep it from helping.
- 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?
- Your service handles requests with threads and a colleague proposes processes instead. What would you compare, and when would you push back?
- The first screen of an image-heavy page opens slowly. How would you work backwards from the symptom to the cause, and what would each improvement cost?
- What happens between writing a line of code and the CPU running it? Pick a language you know and walk through the main stages.
- When two transactions modify the same data at once, what anomalies can occur? What does each isolation level prevent, and what does it cost?
- A new index speeds up queries, but write latency and storage growth worsen noticeably. How would you decide whether to keep it?
- After an async task starts, the caller immediately mutates an input object, and results sometimes change. How would you determine whether this is shared mutable state, copy semantics, or an ownership issue?
- Two usernames that look identical are treated as different, or distinct spellings are treated as the same. How would you analyze Unicode normalization and identity comparison?
- From a file or the network to picture and sound playing, what stages does a video go through? How do decoding, audio-video sync, stutter, and hardware acceleration each affect the experience?
- 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?
- 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.
- 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?
- 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 search field briefly freezes after typing even though the network request completes quickly. How would you use the event loop, task queues, and main-thread occupancy to explain it and locate long tasks?
- Scrolling a list lowers frame rate, and the performance trace repeatedly shows layout work. How would you determine whether code is causing layout thrashing, and why does DOM read/write order matter?
- A service has stable average latency but periodic p99 spikes near allocation peaks. How would you determine whether garbage collection is responsible and distinguish it from other pauses?
- A request starts several async tasks. After the client disconnects or the request times out, some downstream work still uses threads and connections. How would you propagate cancellation and release those resources?
- A set of asynchronous callbacks prints the same loop variable or a value different from what was expected. Using a language you know, explain binding and closure capture, then give a verifiable correction.
- A compiler may reorder or eliminate code. Which program behavior may it change, and which externally observable behavior must it preserve? Explain with a concurrency or I/O example.
- An object overrides equality but keeps the default hash implementation, causing failed lookups in a hash collection. Explain the equality/hash contract and how you would test it.
- A library’s generic type information is unavailable at runtime, causing reflection or serialization to behave unexpectedly. Explain which runtime behaviors erasure affects and how you might redesign the API.
- A service’s resident memory is stable, but major page faults, disk I/O, and tail latency rise together. How would you distinguish changes in the working set, mapping behavior, memory pressure, and application access patterns?
- Clients report occasional request timeouts while server processing time looks normal. How would you use TCP retransmissions, RTT, and connection state to locate where the delay occurs?
- Two processes both access address 0x1000. Why do they usually not read or write the same physical memory? Explain the address translation and operating-system responsibilities.
- After deployment on a multi-socket machine, threads move across NUMA nodes and memory latency varies. How would you investigate using CPU affinity, memory placement, and scheduling behavior?
- After certificate rotation, short connections work, but some clients fail a handshake when reconnecting or resuming after a long-lived connection closes. How would you distinguish certificate-chain, resumption, connection-pool, and client-cache effects?
- When a mobile device switches from Wi-Fi to cellular, some HTTP/3 requests fail while the session still appears online. How would you investigate path migration, timeouts, and middlebox behavior?
- A program writes a data file before updating its index, but after a power loss the index points to incomplete content. How would you analyze write ordering, flush semantics, and recovery?
- Two requests almost simultaneously check that a business object is absent and then both create it; the application-level check-then-write occasionally produces duplicates. How would you use transaction isolation, unique constraints, and conflict handling to preserve the invariant?
- A function appears read-only under multithreading, but a formatter it calls uses a shared internal buffer and occasionally mixes results. How would you distinguish thread safety, reentrancy, and statelessness, and decide where to fix the issue?
- A shared cache is read-heavy and the team plans to replace a mutex with a reader-writer lock. What evidence would you gather, and how would you judge whether the added complexity is worthwhile?
- A migration across millions of records cannot fit in one transaction. The business cannot expose a partially completed state. How would you design batched writes, visibility, and recovery?
- A service accumulates monetary values with floating-point numbers, and reconciliation drift grows over time. How would you identify the source and redesign calculations while migrating historical data?
- CPU averages 35%, but the request queue keeps growing and threads wait on external I/O. How would you identify the real capacity bottleneck?
- Database storage grows while cleanup scans cannot reclaim space; reporting transactions run for hours. How would you diagnose and govern this?
- Instance health checks verify only process liveness, while user requests fail on a critical dependency timeout. Adding every dependency to probes may remove all instances. How would you design this?
- Multiple regions accept the same request independently. Idempotency records have a TTL and machine clocks may differ by seconds. How would you prevent duplicate writes at expiry boundaries?
No questions in this section match your target. ·
Coding and abstraction29
Turning a need into correct, readable, evolvable code with fitting abstractions.
- How do you usually handle null values, empty strings, out-of-range access, and invalid input when writing code? Tell me about a time a missing up-front check caused a problem in testing or production, and what habit changed as a result.
- A sign-up form ends up in inconsistent states because of duplicate submissions and weak-network retries. How would you map its states and transitions, and decide which logic to extract into its own unit?
- Implement a small cache that evicts the least recently used entry when full. What time cost does each operation need, and which tests do you write first?
- A user backgrounds the app while editing, and the operating system may kill its process. On return, which state should be restored and which should be reloaded, and how would you avoid losing a draft or overwriting newer data?
- You need a structure that supports fast insert, fast lookup, and ordered iteration. How would you choose among candidates, and what would you give up?
- 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?
- 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?
- 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 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?
- After a service is registered as a singleton, different user requests occasionally see one another’s temporary state. How would you explain dependency-injection lifetimes and design a safe object boundary?
- After a list item changes from record A to record B, its input still contains A’s draft. How would you explain component identity, keys, and state reuse, and choose where to fix it?
- A custom dialog works with a mouse, but keyboard users cannot reliably enter, close, or return from it. Which focus-management behaviors would you inspect, and how would you verify a fix?
- Design a reusable virtualized list: it renders only visible rows, but selection state must not leak to different data when DOM nodes are recycled. How would you define the interface and test it?
- Given a set of records that may exceed memory capacity, process them in batches while allowing the caller to cancel. Describe or implement an interface that bounds memory, locates errors, and starts no new batch after cancellation.
- Several callers read a configuration file whose fields keep growing; older fields may be absent, and new versions must allow unknown extension fields. How would you design a parsing interface so callers can understand defaults, validation errors, and backward-compatibility behavior?
- 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?
- Events arrive as a stream, and some duplicates may be hours apart. Memory must remain bounded, and deduplication must survive process restarts. How would you define the time window, persistent state, and false-positive boundaries?
- Several product teams override shared component styles with CSS, causing frequent regressions after upgrades. How would you choose between adding configuration, splitting the component, or keeping exceptions?
- Given many timestamped records, return the top K by score and preserve earlier items on ties. How would you implement it and analyze edge cases?
- Several sources are individually time-sorted, but total data exceeds memory. Explain how to merge output and handle a source that slows or disconnects temporarily.
- You need retries and timeouts for an async function. On final failure, callers still need each attempt’s error and whether side effects occurred. How would you design the result?
No questions in this section match your target. ·
Debugging24
Narrowing from a symptom, forming hypotheses, verifying, and fixing.
- Your endpoint works in local tests, but during integration a frontend colleague insists it errors or returns nothing. What means do you use to locate the problem, and how do you produce evidence the other person will accept?
- 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?
- An API has been slow since yesterday, and there is no release on record. Given logs, monitoring, and database slow-query records, in what order would you investigate?
- After splitting a large frontend bundle into several smaller ones, the first screen got slower. What causes would you suspect, and how would you verify them?
- 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?
- 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 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?
- 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?
- A page has valid server-rendered HTML, but content flickers after hydration and the console reports a warning. How would you locate the difference between server and client rendering?
- During a cross-time-zone handoff, a critical alert was sent. The outgoing on-call engineer assumed the incoming engineer would handle it, while the incoming engineer never acknowledged it; escalation was delayed. How would you reconstruct the ownership chain, fix acknowledgment and handoff, and verify the change?
- After a downstream service becomes unstable, upstream traffic appears flat while request counts and queue depth double and several services time out. How would you determine whether retries are amplifying the failure?
- Average latency is stable while p99 worsens, with large differences across tenants. How would you narrow the cause to queuing, lock contention, downstream fan-out, or resource isolation?
- At peak load, the entry service records a request but downstream events are missing, while retries amplify traffic. How would you trace the request through each service to locate loss and duplication?
- Latency is normal after a release, but p99 rises gradually after several hours and temporarily recovers after a restart. CPU is steady while connection counts and heap memory slowly grow. How would you break down hypotheses and design low-risk tests?
- A feature works on the corporate network and most home networks, but requests often time out on a particular carrier or under poor connectivity; server error rates do not rise at the same time. How would you isolate causes across client, network path, protocol, and retry behavior?
- 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?
No questions in this section match your target. ·
System design74
Clarifying requirements and constraints, shaping components, weighing capacity and failure.
- 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 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?
- After reads move to replicas, users sometimes cannot see a change immediately after a successful write. How would you define and handle stale reads?
- 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?
- Two services write directly to the same business table, and an immediate shutdown is impossible. How would you gradually establish a single data owner?
- An order is updated successfully, but a cross-service report reflects it minutes later. The product asks for “real-time status.” How would you define and implement consistency expectations?
- A cross-service flow includes payment, inventory reservation, and shipment. How would you define compensations and irreversible boundaries when later steps fail?
- Incidents recur at service boundaries. Each team can show its service is healthy, but nobody owns end-to-end recovery. How would you repair accountability?
- Several services have separate owning teams, yet a small change often requires three or four teams to release together. How would you assess whether the service boundaries have failed?
- 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 user edits offline and queues several changes. When connectivity returns, the token has expired and some requests may already have reached the server. How would you design reauthentication, idempotency, and conflict handling?
- 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?
- How should the permission system of a large operations back office be designed? How do you organize roles, data scope, approvals, and audit, and how do you keep it from getting out of control as permissions multiply?
- How would you design an article editing and publishing system? How should state and data be organized for drafts, review, scheduled publishing, multi-channel distribution, and edits after publication?
- 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?
- How would you design an online audio or video editor? How should the timeline, assets, non-destructive editing, preview, and final export each be designed?
- How would you design a platform where operations staff build campaigns and game mechanics themselves? How do you abstract campaigns, mechanics, rules, and features into configurable parts, and how do you keep a configuration correct once it goes live?
- Before drawing any architecture diagram, which few numbers would you use to decide whether a service should be split or cached? Use a service you know to explain.
- How would you design a document system for real-time multi-user editing? When several people edit the same passage at once, how do you guarantee eventual consistency, and how do you merge after offline edits?
- From an engineering view, how do you estimate the overall cost of a system? How are storage and compute costs each calculated, and which grow linearly with scale and which do not?
- When the business operates across several countries and regions and user data must flow across borders, how do you solve data compliance in systems and processes, and how do you judge and decide in gray areas where the rules are unclear?
- The local database has updated, but syncing the cache or sending a downstream message fails. How would you make the systems converge and handle retries, compensation, or manual recovery?
- 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?
- How would you design a product where a person and an AI write together? How are the AI's edits shown, accepted, or rejected, and how are conflicts handled when both edit at once?
- How would you design an immersive audio and video feed so that swiping up and down has almost no waiting? How do you balance preloading, player reuse, memory, and data?
- Design a collaboration product that supports large-file uploads with resumability, where files must be validated and scanned before other members can access them. What constraints would you clarify, and how would you design upload, temporary storage, scanning, publication, permissions, and cleanup boundaries?
- How would you design a large-model chat system? How do you handle streamed output, multi-turn context, history, interruption, and retries, and how do you control cost and latency?
- How do the costs of a recommender system add up, including retrieval, ranking, feature serving, storage, and experimentation? How would you trade effect against cost?
- How would you design an invitation-based viral marketing campaign? How do you design invitation relationships, reward payout, abuse prevention, and effect evaluation?
- To build an online editor like Doc, PPT, or PS, how do you design the core data model and rendering? How do you handle undo and redo, selection, and performance on large files?
- How would you design a real-time risk control system? How do rules, features, models, and manual review work together, and how do you trade false blocks against misses?
- How would you design a search system? How do indexing, retrieval, and ranking divide the work, how are Chinese segmentation and features built, and how do you judge how good the search is?
- How should the loading and request strategy of streaming media be designed so it starts fast and does not stall? How do you trade off segmenting, adaptive bitrate, preloading, and caching?
- Tell me about a project you worked on. Why did you choose that technical approach over the others, how was the decision made, and what were its pros and cons?
- How should coupons, discounts, and flash sales integrate with a trading system without slowing the core transaction flow? How would you calculate, combine, and reconcile discounts?
- 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?
- 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 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?
- 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?
- 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?
- After adding authentication, logging, and error-handling middleware, some failures lack trace IDs and unauthorized requests still trigger expensive parsing. How would you analyze pipeline order and boundaries?
- The page HTML arrives quickly, but users still wait a long time to see the main content. How would you trace blockers across resource discovery, download, parsing, execution, and painting?
- A high-traffic service must move a critical table to a new model without pausing reads or writes. How would you organize the migration stages and verify a safe cutover?
- A collaborative tool shows who is online and where they are editing. Brief delay is acceptable, but disconnected members must not remain online indefinitely. How would you design updates and expiry?
- A product needs to send transactional and optional marketing notifications to tens of millions of users, who can change channel preferences at any time. How would you design the sending process?
- A global service must enable different features and retention rules by region while headquarters still needs an overall operational view. How would you divide configuration, enforcement, and aggregation?
- A search service must change tokenization and ranking features without long result gaps or a major increase in write latency. How would you evolve the index?
- A subscription product includes trials, renewals, grace periods, refunds, and family sharing. How would you design entitlement checks so several services receive consistent, traceable results?
- A usage-based API product must combine request events from multiple regions into customer bills and allow later corrections. How would you design the usage-data processing flow?
- A multi-tenant platform must send event notifications (webhooks) to customer systems. How would you design delivery and retries when a client is unavailable for a long time?
- Several tenants share an asynchronous job platform, and some submit many long-running tasks. How would you design scheduling, isolation, quotas, and use logs, metrics, and call records to understand queue behavior?
- Some objects become hot, degrading reads while writes must remain ordered. How would you divide caching, partitioning, and write coordination?
- The business needs every state change to be traceable and safely replayable, but some old events lack fields. How would you design event versions, retention, and replay boundaries?
- A multi-region service must preserve critical functions during a regional outage, but some data cannot tolerate conflicting overwrites. How would you choose degradation, replication, and recovery policies?
- A real-time collaboration service has many long-lived connections, and slow clients accumulate updates. How would you choose between dropping, combining, limiting updates to slow clients, and resynchronizing?
- Different teams own creation, editing, and review, and their form feedback is becoming inconsistent. How would you decide which patterns to standardize and which to keep distinct? How would you check loading, empty, error, and recovery states?
- Users can edit a profile on a phone while offline and may also edit it on the web. The device must sync when connectivity returns without silently overwriting valuable changes. How would you design versioning, conflict detection, merging, and user confirmation?
- An entry service calls several downstream systems. One noncritical dependency occasionally slows down, exhausting request threads and affecting unrelated features. How would you design timeouts, concurrency isolation, degradation, and recovery?
- 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 live index needs a new shard key as data grows quickly and writes cannot stop. How would you plan old and new indexes and decide when to cut over?
- A multi-tenant query platform shares a database pool. One tenant submits many complex reports and increases latency for others. How would you isolate and meter usage?
- An admin API can change customer states in bulk. A script began calling it directly and caused broad changes. How would you redesign authorization and safeguards?
- A user starts a large export and disconnects; access is revoked while the job runs. The job needs resumability without leaking data after revocation. How would you design it?
- Product data lives in application, CDN, and client caches. After a price update, users see different values. How would you define refresh, versioning, and invalidation semantics?
- A live dashboard uses event-time windows, while finance groups by settlement time and excludes unsettled transactions. A leader believes one report must be wrong. How would you explain and govern this?
- Every read request is logged, driving cost up, while compliance requires evidence for sensitive actions. How would you tier collection and retention?
No questions in this section match your target. ·
Engineering systems49
Build, release, repository workflows, and the quality tooling around them.
- 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?
- 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?
- Your solution depends on a lower-level service or library. If it changes substantially, how would you migrate, fall back to a version that preserves core features, or replace it?
- 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?
- In the technical area you work in, how is the industry developing? Is your solution adapting to that trend or going against it?
- 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?
- 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?
- What technical gains did this project bring? How do you measure them, and what complexity and maintenance cost did you pay for them?
- 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?
- After independently developed apps are integrated, styles collide, themes differ, and overlays are clipped. How would you choose a style-isolation strategy?
- Several frontend modules build independently, but releases still require coordination. What evidence would show they have a real independent delivery boundary?
- A large frontend makes parallel delivery difficult, but splitting it into several apps at once is risky. How would you plan an incremental migration and judge each step?
- If a micro-app fails at startup, users cannot access other modules. How would you isolate the failure and, if needed, disable noncritical features to keep the rest available?
- Several child apps depend on different React and component-library versions, causing both duplicate downloads and runtime conflicts. How would you govern shared dependencies?
- Several child apps share the browser address bar, but back/forward, deep links, and login redirects behave inconsistently. How would you define a routing contract?
- After code changes, the build system sometimes misses affected apps and sometimes rebuilds the entire repository. How would you validate the dependency graph and cache invalidation rules?
- One repository contains multiple teams and production deployment config, but code-owner rules do not cover temporary admins and automation accounts. How would you review permission and approval boundaries?
- Two product packages form a dependency cycle, and splitting them creates a need to share domain types. How would you change the boundaries without hiding the cycle in a new shared package?
- A team decides to split a large repository, but history, CI, package releases, and ownership are connected. How would you sequence the migration?
- In a monorepo, shared packages are casually changed by one team, while consumers discover behavior changes only after upgrading. How would you establish ownership and compatibility contracts?
- Packages have very different release cadences, but shared version numbers force unrelated teams to release together. How would you design versioning and release policy?
- The repository has hundreds of packages and full CI is slow. The team wants to test only “affected” areas. How would you prove selective testing does not miss critical dependencies?
- 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?
- 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?
- 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 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?
- After an update, some users occasionally load new HTML with old JavaScript and the page fails. How would you design asset naming, cache policies, and release order to reduce inconsistency?
- Teams share a repository but release at different cadences; shared package changes often block unrelated teams. How would you design boundaries, impact analysis, and release agreements?
- The same release behaves differently across clusters, and configuration changes are not fully audited. How would you establish configuration sources, drift detection, and rollback?
- Teams are copying shared components and adding local variants, making similar features inconsistent. How would you decide which differences belong in the shared design system and which should remain team-specific? How would teams help maintain those rules?
- A shared library releases a backward-compatible version, but application repositories cannot upgrade promptly because of pinned dependencies, generated code, or different release windows; a security fix remains blocked. How would you design compatibility policy and the dependency-upgrade process?
- The same commit passes reliably on a developer's machine but occasionally fails in CI because of time zones, random ordering, shared caches, or parallel races. How would you classify, reproduce, and reduce this nondeterminism?
- 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?
No questions in this section match your target. ·
AI engineering47
Evaluation, retrieval, agents, and the engineering limits of model-backed features.
- 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?
- You built a customer-support Q&A prototype. How would you design an evaluation set to decide whether it may only assist retrieval, or can reply to customers directly?
- What does an algorithm model and the features it depends on truly cost? How do you count training, inference, feature computation and storage, labeling, and maintenance, and how do you judge whether a feature is worth keeping?
- 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?
- A resume line saying "used AI to improve engineering efficiency" carries little information. How would you rewrite it into an experience others can probe and verify?
- 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?
- After changing an embedding model, old and new vectors are not directly comparable, while a full rebuild takes days. How would you design migration and query cutover?
- A team discovers that a model may have seen some internal evaluation prompts in public corpora or fine-tuning data. How would you determine what offline scores still mean and rebuild a trustworthy evaluation?
- A team fine-tunes on user feedback, human labels, and synthetic samples, then receives a request to delete some source data. How would you trace impact and decide the scope of retraining?
- A new model improves offline evaluation, but answer quality may fall for a small set of high-value users. How would you stage a canary, observe it, and decide when to expand traffic?
- A product depends on an external model API, and the provider may restrict request frequency or change available models. How would you design switch rules and temporary shutdowns for noncritical features so quality changes after switching are visible?
- Users say answers sound plausible but omit a critical constraint present in the documents. How would you locate whether parsing, chunking, retrieval, ranking, or generation caused the failure?
- Offline evaluations keep improving while a specific user segment regresses online. Which data leakage, slice coverage, and deployment differences would you investigate?
- An AI assistant repeatedly calls search, databases, and external APIs for a small share of requests, making latency and cost far higher than average. How would you design per-task budgets, stop conditions, idempotency, and auditable execution records?
- An AI assistant retrieves documents from several business systems, where users have different permissions in each. How would you ensure retrieval, caching, summaries, and citations follow source permissions, including after access is revoked?
- A model service used by an AI feature has highly variable latency, causing user requests to exceed the end-to-end deadline. How would you allocate budgets across retrieval, model calls, and post-processing, and design fallbacks after a timeout?
- 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?
- Two currently valid policies in the knowledge base conflict, with similar retrieval scores. The assistant must not choose whichever is more convenient. What response and escalation path would you design?
- A new assistant improves satisfaction ratings, but task completion and repeat-contact rates remain unchanged. How would you determine whether this is a real improvement?
- Model responses may echo customer identifiers, while production debugging relies on request and response logs. How would you design collection, redaction, access, and retention?
- Users see response times double, but model inference time has barely changed. How would you break down the request-processing stages, locate the bottleneck, and limit impact?
- The team tunes prompts and model settings against the same fixed evaluation set every week. Scores rise, but new-user feedback does not improve. How would you restore evaluation trustworthiness?
- A model passes evaluations in a major market but behaves inconsistently in a new region because language, terminology, and service rules differ. How would you set rollout scope and follow-up gates?
- To reduce inference cost, the team caches answers by prompt text. User permissions, knowledge versions, and regional rules may differ. How would you define cache keys and invalidation?
- The evaluation set has grown, but many items are slight rewrites of one template, making model scores look stable. How would you audit sample quality?
- A natural-language request omits an amount limit and target account, while the agent can invoke a side-effecting tool. How would you decide whether to clarify, advise only, or require confirmation?
- A template changes only formatting and examples, but output length and tool-call frequency shift. The team wants to skip full regression. How would you tier the risk?
- A new safety policy reduces false refusals but causes sensitive disclosures in a few edge cases. Product wants to keep the satisfaction gain. How would you evaluate?
- A hosted model upgrades without notice. Standard health checks pass, but classification boundaries and output length shift. How would you build safeguards?
- After a safety policy launch, human handoffs double while high-risk errors fall. Operations capacity is limited. How would you assess the result and tune thresholds?
- A model labels some accounts high-risk and automatically denies service, affecting customer rights. How would you set validation, appeals, and human review?
- The business changes “churn” from 60 days without login to 30 days without payment, while historical training and models use the old definition. How would you manage versions and comparisons?
No questions in this section match your target. ·
Product discovery and experience design16
Using user research, prototypes, and experience design to clarify problems and validate solutions.
- A workspace contains hundreds of items that people find by customer, status, owner, or date. Its navigation follows the company org chart, so users struggle to find things. How would you reorganize it and test findability?
- A study was commissioned to validate a new dashboard. Most users say current reports are sufficient; a few advanced users want more. The project lead wants to highlight supportive interviews. How would you summarize the findings?
- In research for a new feature, a small group of frequent users strongly supports the concept, while novice participants repeatedly fail the core task and the analytics show no clear difference. How would you interpret what each piece of evidence can tell you and decide whether to proceed, revise, or run more research?
- In a usability session, the moderator repeatedly asks whether the design is clearer, and users agree. Video shows repeated hesitation during tasks. How would you handle the evidence and next study?
- Interview participants are almost all power users and community members. Feedback on the latest redesign is positive, but retention continues to fall. How would you redesign recruitment and research questions?
- During user interviews, people repeatedly suggest buttons, filters, and reminders but rarely describe their goals or blocked situations. How would you adjust question order and wording to distinguish real experiences, stated preferences, and proposed solutions?
- 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?
- An operations table uses red, yellow, and green for risk. Some users cannot distinguish the colors, and screen readers announce only values. How would you redesign the information?
- A feature targets people who have never used the product, but all usability participants are core users. Which design decisions can the current evidence support?
- After submitting a form, users see “validation failed,” with no field identified and no entered data preserved. How would you redesign the error and recovery path?
- A desktop admin table has 14 columns, while mobile users need to handle exceptions in the field. How would you decide what to retain, hide, or move to details?
- A dashboard flags anomalies but shows no magnitude, baseline, or related events. Users export data to interpret it themselves. How would you improve diagnosis?
- Review feedback centers on “not premium enough” or “I dislike this color,” but the team has no shared user goal. How would you run the next review?
- Operators, managers, and auditors share a workspace but need different information and permissions. How would you design default views and personalization?
- The product serves professionals and must use industry terms, but new users often stop or choose incorrectly. How would you design comprehension support?
No questions in this section match your target. ·
Quality, security, and safety13
Designing for quality validation, reliability, security, privacy, and risk controls.
- 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?
- 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 core flow passes mouse testing, but keyboard or screen-reader users cannot complete it. How would you include accessibility in release gates?
- A critical user journey across several pages and services regresses often. How would you define the scope and priority of automated tests?
- A user requests deletion of personal data, but some records have reached backups, analytics warehouses, and downstream systems. How would you design a verifiable deletion process?
- A widely used dependency is disclosed as critically vulnerable, but upgrading may introduce compatibility issues. How would you sequence the response?
- 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?
- A new external service will access user data and trigger internal actions. How would you perform a lightweight but effective threat model?
- 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?
- Several teams copy de-identified data into development, staging, and performance environments with different refresh schedules. How would you design access, lifecycle, and reproducibility?
- A core service remains within its monthly SLO, but its error budget is being consumed much faster and errors cluster around a recent feature release. How would you decide whether to pause rollout or roll back?
- 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?
No questions in this section match your target. ·
AI evaluation and governance12
Establishing evaluation, access controls, risk monitoring, human oversight, and accountability for AI systems.
- Public benchmarks keep improving while internal task performance stalls. How would you investigate evaluation distortion?
- The product wants confident AI conclusions, but evidence supports only probabilistic judgments. How would you design communication and traceability?
- After AI output causes actual user harm, product, model, operations, and review teams all take part in the response. How would you divide incident handling and follow-up improvement?
- 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?
- You need to sample production AI conversations for emerging risks, but they contain personal or commercial data. How would you design the review?
- 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 new model scores much better on an offline test set, but a small production rollout shows lower task completion for one user group and more complaints. How would you determine where the evaluation set, metrics, or release decision failed?
- 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. ·