Coding Interview Questions for Infra Engineers

Build a small decimal billing calculator with an explicit rounding policy, exact durations and tests for invalid records and credits.

Two parameters, one lazy refill and one lock. What capacity and rate each control and why conflating them is the usual bug, the clock choice that avoids a whole class of failure, and the retry-after value that turns a rejection into something a client can act on.

The union is a sort and a scan. The intersection is the same sweep with a counter, and it is the one that goes wrong, because a single GPU reporting overlapping intervals will be counted twice and produce an answer that looks plausible. Both implementations, the trap, and the tests that catch it.

Implement bounded retries with full jitter, a shared credit budget and a cooperative deadline. Test repeatability and explain what a timeout leaves uncertain.

Per key, an ascending list of versions and a parallel list of values, with reads doing a binary search. The three cases that decide whether the design is right: a key that did not exist yet, a key that was deleted, and a version at which some other key was written.

Implement size- and timer-triggered batching, then test cancellation, handler errors and the latency added before dispatch.

Implement priority admission and completion, preserve a preempted job’s sequence, and distinguish a sufficient greedy victim set from an optimal one.

Stream a trace with an explicit record format, bounded access groups and measured aggregation size. Preserve group identity and report rejected data.

Build a byte-budget cache with reference-counted pins and admission that preserves existing entries when it fails.

Implement a bounded producer-consumer pipeline with explicit shutdown and error reporting. Keep work outside collection locks and account for memory beyond the input queue.

Compare three GPU placement heuristics with executable traces. Show how admission and free-space shape change, then add workload and topology constraints.

Decode fragmented UTF-8 with an incremental codec. Test malformed bytes, truncated endings and the boundary between byte decoding and event parsing.

Simulate both phases of ring all-reduce and verify values, preserved inputs and each rank’s payload bytes.

Build a reference-counted KV block allocator and test that forked sequences keep their data independent when either branch appends.

Simulate admission, decode growth and preemption. Check memory accounting and useful progress with the same finite workload.

Write a bounded Go downloader that propagates cancellation, joins every worker and publishes files under explicit unique names.

Implement a stable hash ring, test which keys move, and distinguish balanced ownership from balanced serving traffic.

Implement stable temperature, top-k and top-p sampling with explicit tie rules, masks, invalid inputs and probability tests.

Reconstruct GPU-hour intervals, clip them to a period and preserve provisional usage and conflicting-event evidence.

Implement bounded recovery probes, state-generation tickets and a recent failure window. Test concurrency and late completions.

Detect missing and silent ranks from a roster, distinguish liveness from progress, and derive thresholds without assuming independent delays.

Implement shared and sharded C++ counters, explain relaxed ordering and test final counts without promising unmeasured scaling.

Compare standard-map guarantees with flat-table layouts. Implement bounded probing and choose from semantics and representative measurements.

Implement owner-pop and thief-steal semantics with correct accounting for running tasks that generate children.

Derive and simulate speculative output counts, then compare them with explicitly assumed or measured round costs.

Design job creation, cancellation and listing around retries, durable ownership and an explicit pagination contract.

Allocate tasks by current dominant share and distinguish per-user fairness from cluster feasibility and physical placement.

Write and verify tiled NumPy matmul, derive its logical footprint and distinguish a cache model from the causes of measured runtime.

Build a complete segmented metrics-store reference with duplicate-safe range queries, visible retention and tested compaction.

Check useful progress before interpreting GPU activity. Run a bounded trace exercise that exposes a rank-conditional call, equal-count ordering errors and matching shapes with the wrong tensor meaning.

Apply a learned merge order without retraining on the input. Test overlapping pairs, preserve UTF-8 bytes, and turn tokenizer differences into a capacity estimate.

Keep live and completed candidates separate, score whole sequences, and trace a case where greedy decoding loses. Explain the cache cost of branching.

Follow the matrix shapes through a low-rank update. Verify merged inference numerically and show why multiplying sums of adapter factors gives the wrong weights.

Build a reverse-mode graph for addition and multiplication. Use a repeated input to expose overwritten gradients, then check the derivative numerically.

Keep request timing independent, make snapshots consistent, and expose overwritten records. Test the ring after more concurrent writes than it can retain.

Define when expiry is observed, stage writes privately, and reject a conflicting commit. Use a small conservative protocol before optimizing concurrency.

Build a small CPU reference, overwrite a bounded KV ring, and compare every step with a recomputed attention window. Keep model semantics separate from eviction.

Derive the scale, handle zero tensors, clamp before casting, and separate rounding error from clipping. Compare one outlier under tensor and channel scales.