A · Professional problem solving and implementation
Computer-science foundations
Algorithms, operating systems, networks, and databases, and how they explain real behavior.
Classification boundary
Include: Include questions that test algorithms, languages, operating systems, networks, or database fundamentals.
Choose a neighboring leaf when: Use system design when the main evidence is an architectural trade-off, and coding when it is implementation.
This capability may appear in standards across different stages. Explore stage expectations
45 questions
Choose a group based on the evidence you need. Groups follow existing question formats, not difficulty or mandatory prerequisites. Each batch has up to eight questions.
Concepts and boundaries27
Check concepts, assumptions, and conditions of use.
Questions 1–8
- 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.
No questions in this section match your target. ·
Questions 9–16
- When two transactions modify the same data at once, what anomalies can occur? What does each isolation level prevent, and what does it cost?
- 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?
- 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?
- 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 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 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.
No questions in this section match your target. ·
Questions 17–24
- 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?
- 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?
No questions in this section match your target. ·
Questions 25–27
- 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?
No questions in this section match your target. ·
Judgment and options14
Compare goals, constraints, options, and trade-offs.
Questions 1–8
- 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 new index speeds up queries, but write latency and storage growth worsen noticeably. How would you decide whether to keep it?
- 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?
- 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 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?
No questions in this section match your target. ·
Questions 9–14
- 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 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?
- 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. ·
Implementation and verification4
Examine execution, verification, and correction.
Questions 1–4
- 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?
- 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?
- 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?
No questions in this section match your target. ·
No questions in this capability match your target. ·