Modal Coding for Infra interview questions

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

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

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

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.

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.

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

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

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.

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

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

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.

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

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

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

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