USE CASE
Campus hiring
These are the same questions found in the library, grouped here by the capability each one mainly examines.
108 questions
Questions 1–50 of 108 on this page.
A · Professional problem solving and implementation47
- 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?
- 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?
- 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?
- 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?
- 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 reads move to replicas, users sometimes cannot see a change immediately after a successful write. How would you define and handle stale reads?
- 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 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 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?
- 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?
- 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.
- 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?
- 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?
- 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 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 modeling3
- How should amounts, currencies, rounding, and time zones be expressed in a transaction and settlement model? Which practices look fine but break at reconciliation?
- In a behavioral event table, what exactly does one row represent? Explain how you settle its grain, and which statistics go wrong when the grain is unclear.
- Orders, payments, and refunds are often stored in one table. How would you distinguish their business identities, lifecycles, and cardinalities? Compare conditions, costs, and validation for separate models and combined storage.
No questions in this section match your target. ·