ROLE
General software engineering
Compare expectations across career stages →
These are the same questions found in the library, grouped here by the capability each one mainly examines.
1313 questions
Extended questions 201–250 of 1313 on this page.
A · Professional problem solving and implementation49
- 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?
- 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 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?
- 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?
- 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?
- 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?
- 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?
- 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?
- 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?
- 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?
- 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 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 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 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?
- 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?
- 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?
- 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?
- 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?
- 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?
- 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?
- 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 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?
- 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.
No questions in this section match your target. ·
D · Delivery and ongoing operations1
No questions in this section match your target. ·