The senior ML interview canon

The textbook distinction is philosophical. The practitioner distinction is whether you can sample from a posterior cheaply, and whether you need uncertainty for downstream decisions.

Backprop is reverse-mode automatic differentiation. It reuses forward-pass values to compute all parameter gradients at roughly one additional forward-pass cost.

Check update stability, propose a learning-rate peak, then test its schedule from a clean starting state.

Choose a loss from the target, noise model, error cost, and output constraints. A well-trained model still fails when its objective is wrong.

Solve a common quadratic under absolute and squared penalties, test the zero subgradient condition, and separate objective sparsity from solver behavior.

The classic warm-up question. The L4 answer is the formula; the L6 answer is what it tells you about model selection in production.

Cross-validation is a tool, not a default. The senior answer names the cases where it's wrong, expensive, or misleading.

The trick is that there are three valid explanations and they all matter. Which ones you reach for tells the interviewer your level.

A research-depth framework for claims, baselines, evidence, leakage, compute fairness, ablations, and generalization.

A strong derivation states assumptions, exposes the key identity, checks the result, and explains what it means for model behavior.

Standard math-screen question. The senior signal is whether you can derive it cleanly and connect MLE to cross-entropy.

Separate a model improvement from extra compute, data, parameters, tuning, and implementation confounds.

Differentiate a smooth parameterized sample path with fixed base noise, then distinguish its gradient estimate from the expectation gradient.

Turn an observation into competing hypotheses, discriminating probes, boundary conditions, and one decision-changing result.

The gradient simplifies to (p - y), and that's not a coincidence. The senior answer derives this and connects to GLMs and numerical stability.

A loss spike is an incident: preserve evidence, classify the failure, isolate the first bad transition, and recover without hiding the cause.

Trace gradient buffers and module mode, separate demonstrated defects from missing contracts, then execute a corrected CPU training fixture.

The new coding signal is control: map the system, delegate bounded work, reject bad changes, and prove the result.

The code is small; the signal is low-rank parameterization, zero-impact initialization, scaling, trainable-state control, and deployment trade-offs.

The code tests tensor contracts, causal masking, stable attention, residual structure, and whether you can connect a toy block to production kernels.

The coding question that doubles as a depth check. The code is short; the conversation around it tells the level.

The implementation tests bounded hypothesis state, log-probability accounting, finished-sequence handling, and whether the decoder fits the task.

Prove that one-token cached attention matches full-prefix attention while preserving shape, dtype, growth, and memory invariants.

The naive solution is one line. The interview is about scaling: when does naive fail, and what do you do?

Retrieve top-k cosine neighbors for many queries without materializing the full query-by-item score matrix.

Build a bounded-memory confusion-matrix accumulator with merge, precision, recall, F1, and edge-case handling.

Build the computation graph, local derivatives, gradient accumulation, and reverse topological pass behind neural-network training.

Performance engineering is a measured argument: identify the bottleneck, predict the effect, preserve correctness, and shorten the critical path.

Moderation is a multi-policy classification problem at scale, with appeals, human review, and adversarial users. The senior answer separates policy from model and treats human review as part of the system.

A feature store solves training-serving skew, feature reuse, and lineage. The senior answer explains why each property matters and what minimum viable looks like.

A deep case on lawful sourcing, provenance, curation, contamination, mixtures, high-throughput processing, deletion, release gates, incidents, and multi-level technical judgment.

A staff-level case covering platform scope, data contracts, training, deployment, governance, migration, ownership, cost, and adoption across product teams.

Turn prefill, decode, KV memory, admission, batching, fairness, overload, and cost into one explicit serving policy.

A deep system-design case covering synchronized live media, streaming models, latency, failure recovery, privacy, evaluation, rollout, incidents, and multi-level technical decisions.

A cost-constrained system-design question where quality, latency, traffic, and annual spend must fit one defensible operating point.

Classify fail-stop, straggler, state-divergence, and silent-corruption failures before choosing restart, elasticity, redundancy, or repair.

Design payment-risk decisions while preserving action, label maturity, audit provenance, point-in-time features and the costs of mistakes.

Separate service health, input contracts, model behavior, mature outcomes and causal comparisons; attach each alert to evidence and an owner.

Real-time personalization fails most often at the data infrastructure, not the model. The senior answer designs the feature freshness and serving stack first.

Define metric populations, horizons and decision roles, then apply a joint release rule without overriding its guardrails.

Turn an offline model gain into a valid product decision: unit, exposure, power, guardrails, interference, and a ship rule.

Chatbot A/B testing has all the hard parts of regular A/B testing plus delayed feedback, conversational state, and metrics that are hard to define.

Separate experiment validity, delivered treatment and product outcomes before attributing an online regression to the model.

BPTT is just backprop on the unrolled computation graph of a recurrent network. The interview signal is whether you understand truncation and what it costs.

Match the treatment to the imbalance ratio, error costs, label process, and decision metric. Class weighting and SMOTE are only two options.

Isolate loss, gradient, and parameter-update failures with a reproducible batch before escalating to optimization or task mismatch.

Beyond 'use BF16'. The senior answer explains what stays in FP32, why loss scaling exists for FP16, and the memory split.

Turn a model configuration and cluster budget into parameters, memory, parallelism, time, and an experiment plan.

A deep system-design case on allocating fixed accelerator capacity across reasoning-model training, verification, evaluation, routing, serving, reliability, and organizational ownership.

The question is about parallelism and memory, not about modeling. The L6 answer combines data, tensor, pipeline, and FSDP/ZeRO sharding into a coherent strategy.

Separate measured optimizer performance from coordinate-dependent sharpness, decay coupling and unequal tuning or resource budgets.

Bind inline suggestions to editor state, retrieve authorized context, discard stale responses and verify a separate tool-enabled task workflow.

Legal RAG amplifies every standard RAG concern: precise citations, no hallucinations, regulated domain, dense documents with structure. The senior answer addresses each.

A deep case on independent runtime controls, safety cases, monitors, circuit breakers, approval, evidence, degraded operation, incidents, evaluation, and upper-IC judgment.

Design a bounded record-summary workflow around patient identity, encounter dates, source evidence, clinician authority and controlled changes.

A deep system-design case covering four coding modes, repository context, safe execution, evaluation, developer control, rollout, cost, and organization-wide technical decisions.

A deep architecture case covering delegated authority, tool contracts, durable state, safe retries, memory, evaluation, observability, rollout, cost, and multi-organization governance.

Start from assets and attacker capability, test the whole agentic system adaptively, and turn findings into measurable release gates.

Turn one capability into episodes, evidence-bearing graders, adversarial data, and a training signal that cannot reward the wrong process.

Past the basic decision tree. The senior answer covers SFT, LoRA, DPO, continued pretraining, and the operational trade-offs each introduces.

Agent eval is harder than chat eval because there are intermediate steps, tool calls, and long-horizon outcomes. The senior answer evaluates trajectories, not just final outputs.

There is no single solution. The senior answer is a layered system that catches different hallucination types at different stages.

Code is one of the few LLM domains where ground truth is verifiable. Use that. The senior answer combines verifiable metrics with human review for what verification can't catch.

Define task success, combine hard checks with supported-answer review, and make an evidence-limited release decision.

The cost-engineering question. The L6 answer doesn't pick a technique, it diagnoses where the cost is, then picks five.

The interview signal is whether you understand why decoding is memory-bound and why the verify pass is essentially free.

Locate a failed requirement, test the suspected cause and compare prompts, retrieval, training or a simpler implementation.

Distinguish complements from similarity, compare co-purchase rates with lift, and separate attributed orders from useful incremental purchases.

A deep recommendation case balancing viewer value, creator opportunity, quality, revenue, concentration, experimentation, operations, and portfolio choices across a short-form video ecosystem.

Compose coherent music shelves under page-level utility, repetition, editorial, freshness and privacy constraints rather than sorting unrelated local scores.

Scope a video recommendation surface, compare conditional objectives, trace candidate coverage and preserve exposure before learning from feedback.

Use permitted context, item content, optional preferences and bounded exploration while measuring feedback uncertainty and whole-cohort outcomes.

Evaluate a search ranker with judged queries, explicit averaging weights, exposure controls, slice guardrails and a recorded release decision.

Choice of negatives often matters more than choice of model. The senior answer ranks the strategies (in-batch, hard, BM25-mined, model-mined) and explains the trade-offs.

The recsys / search architecture decision that comes up in every retrieval interview. The right answer is 'both, in sequence.'

Choose a changed task, budget optional inference, compare simpler baselines and validate generated recommendations against the current catalog.

Explain a real values decision using prior evidence, competing concerns, obligations, ownership and observed outcomes without rewriting the record.

Compare feasible portfolios against their next-best alternative, protect mandatory obligations and explain a real chosen-versus-declined decision.

Scoping is a core senior skill. The interview tests how you reduce ambiguity before choosing a model or system design.

Present owned decisions with credible alternatives, prior evidence, technical depth and honest outcome limits, even when questions change the order.

A senior behavioral question about evidence, proportionate pushback, stakeholder pressure, and responsible trade-offs.

The standard behavioral question. The interviewer is checking whether you can hold technical positions, push back productively, and update on new information.

A staff-level behavioral and project question about sunk costs, evidence thresholds, influence, and responsible stopping.

The interview is checking the size of problem you can hold in your head and the structure of how you describe it. Specificity wins.

Critique a specific technical use with task evidence, cost, uncertainty and a useful boundary; state what would change the recommendation.

Return every unique group of three numbers whose sum is zero.

Separate one-digit and two-digit decoding choices, preserve both rolling dependencies, then enumerate witnesses or change the token vocabulary.

Memoize copies before discovery, then preserve every ordered adjacency entry across cycles, shared nodes and multiple roots.

Prove two-frontier sufficiency, preserve node identity while rewiring, then copy the output or change both source and comparison order.

Return a certified subtree height or failure, propagate failure before combining, and distinguish local height from whole-tree balance.

Summarize the cheapest eligible baseline for each sale, preserve optional profit, and change update timing for witnesses and mandatory trades.

Compute precision and recall from binary labels and predictions.

Find a target in a sorted array.

Return one extendable branch, score two branches locally, and keep nonempty path sums distinct from height or diameter.

Follow trie edges for literals, explore character alternatives at each dot, then change existence into counting or iterative matching.

Compute one attention head where each token can read only itself and earlier tokens.

Combine same-index reuse with a nondecreasing choice boundary and positive remaining-target decrease, then switch to finite occurrences or count-only DP.

Partition ordered sequences by their final value, distinguish total-first from denomination-first counting, and add a length bound before allowing nonpositive values.

Match values and corresponding child positions, then change alignment or ignore labels explicitly.

Name the two prefix optima, derive skip versus take, then change endpoint conflicts or recover selected indices.

Use maximum-jump prefix reachability, reject gaps before expansion, then change the destination or count minimum layers.

Consume preorder roots within exact inorder ranges, build children in the required order, and validate compatibility rather than only matching value sets.

Pick two heights that hold the most water.

Compare input and distinct cardinalities, preserve complete set construction, and retain positions only when duplicate distance matters.

Derive rolling path counts from final-move cases, then change valid landings or allowed positive jumps.

Erase land on discovery so each component has one counted seed, then change ownership or reduce component area.

Count subarrays that contain exactly `k` odd numbers.

Reuse a smaller integer's completed population count instead of recounting every binary representation.

Save the zero-indegree emission order, reject blocked prefixes, and distinguish any valid witness from lexicographic priority and independent verification.

Compute mean multiclass cross-entropy from logits and integer labels.

For each day, find how many days pass before a warmer temperature.

Decode text such as `3[a2[c]]` into `accaccacc`.

Derive matching and skipping dependencies, preserve old-row values, then change storage orientation or recover a subsequence.

Follow actual node identities, prove the relative-offset collision, then recover the cycle entry and length without changing links.

Price each final insertion, deletion or replacement from its smaller prefix state, retain two rows, and adapt operation costs or eligibility.

Frame payloads with lengths, preserve empty and hash-containing strings, and distinguish trusted character decoding from validated and byte-counted formats.

Separate old sums from new additions, then change to dense coordinates or signed inputs without silently permitting reuse.

Accept a node's first cheapest heap entry, skip later duplicates, then change sources or arrival queries.

Maintain ordered lower and upper heaps at completed insertions, distinguish repair states, and adapt float medians to exact fractions or nearest-rank quantiles.

Retain a minimum inside an inclusive candidate interval, keep a possible midpoint answer, and handle duplicate ambiguity without false logarithmic guarantees.

Capture one queue boundary, preserve depth order, then select or reduce each complete level.

Combine an exact edge count with full undirected reachability, then adapt the proof for forests or an explicit labeled vertex universe.

Use complete character counts as immutable bucket keys, preserve duplicates and input order, and change the alphabet or returned evidence explicitly.

Cover every circularly valid selection with two endpoint-excluding lines, then avoid slices or reconstruct a nonadjacent original-index witness.

Use adjacent words' first differences, reject invalid prefixes and cycles, then report ambiguity or validate a proposed alphabet.

Insert one range into sorted, non-overlapping ranges and merge when needed.

Trace promotion and eviction, keep the map and linked order consistent, then observe without refreshing or shrink entry capacity.

Locate the predecessor of an end-relative target, preserve invalid-rank behavior, then switch to read-only lookup or front-index removal.

Evict the smallest retained occurrence on overflow, then change distinctness or report streaming thresholds.

Prove maximum compatible cardinality by exchange, then request a witness or change to weighted interval selection.

Find the slowest eating speed that finishes all piles within the time limit.

Use inorder as a sorted stream, count pops rather than descent, and add subtree counts only when repeated rank queries justify them.

Find the largest rectangle that fits under histogram bars.

Treat text boundaries as reachable states, reject partial coverage, then reconstruct one segmentation or count distinct parses.

Find the length of the longest run of consecutive values in an unsorted array.

Use strict value growth to justify a coordinate-only suffix cache, then change evaluation order to avoid recursion or count all increasing paths.

Keep the smallest ending value for each achieved length, then recover a witness only when the task requires one.

Expand matching endpoints around character and gap centers, retain the first longest range, and adapt the result to ties or repeated interval queries.

Replace at most `k` letters so the longest possible substring has one repeated letter.

Find the longest substring with no repeated character.

Follow both BST targets together until their routes split, state the membership precondition, and add presence evidence when ordering or membership changes.

Keep both ending-product extremes because a negative multiplier reverses which one can win.

Separate the best sum ending at the cursor from the best nonempty range found anywhere.

Sort positive-length meetings, check neighboring boundaries, then adapt the endpoint and turnaround rules.

Merge many sorted linked lists into one sorted list.

Build a stack that returns its current minimum in constant time.

Split examples into batches without dropping the final short batch.

Track missing copies, save each valid cover before destructive shrinking, and adapt to required-only counters or counting every covering range.

Cancel expected and observed integer values under an exact one-omission contract, then change validation or omission count.

Clear the lowest remaining one at each step, with an explicit nonnegative or fixed-width integer contract.

Launch one flood per uncovered undirected component, retain isolated vertices, and reuse the component sizes to count unreachable pairs.

Trace a board path, restore cells after success or failure, then support arbitrary characters or count every coordinate path.

Put integer sequences into one rectangular array and return a valid-token mask.

Compute the squared distance from every point to every center without Python loops.

Count each accepted center radius as a separate index range, then distinguish occurrence lists from unique palindrome text values.

Check whether any substring has the same letter counts as the pattern.

Choose unused input positions, restore both path and flags between branches, and distinguish partial orderings from unique repeated-value permutations.

For each position, return the product of all other values. Do not use division.

Separate graph paths from representative pointers, then change sparse labels or count remaining components.

Remove eligible prerequisite vertices, account for every outgoing edge, and distinguish blocked residual nodes from actual cycle members.

Solve amount-indexed minimum counts, justify the unreachable sentinel, then recover an optimal witness or minimize unequal costs.

Change `1, 2, 3, 4, 5` into `1, 5, 2, 4, 3`.

Combine child heights for a longest path, then change execution depth or count every node.

Mirror every subtree while preserving node identities, then change execution or return a separate copy.

Consume and append exactly the declared number of bits, including zero positions after the remaining input becomes zero.

Search uphill from each destination border, keep separate reachability certificates, and intersect them.

Rotate a square matrix 90 degrees clockwise in place.

Seed all simultaneous sources before FIFO spreading, mark fresh cells on enqueue, and distinguish scheduled arrival, input mutation and unreachable fresh cells.

Copy each answer before extending a shared path, then change output length or duplicate-value policy.

Maintain disjoint reversed and untouched regions, preserve node identity, then copy the result or use bounded recursive control.

Identify one sorted half, use exact endpoint bounds to retain a target, and handle duplicate ambiguity without promising logarithmic progress.

Frame every recursive child slot with a value or null token, rebuild exact topology, and distinguish trusted decoding from complete-stream validation.

If a cell is zero, set its full row and column to zero. Change the matrix in place.

Trace character edges, distinguish membership from prefix reachability, then delete terminal state or enumerate completions.

Preserve covered points with a sorted union frontier, then change touching policy or count discrete coverage.

Return matrix values in spiral order.

Split an array into `k` nonempty continuous parts. Make the largest part sum as small as possible.

Convert logits to probabilities without numeric overflow.

Count continuous subarrays whose sum equals the target.

Locate candidate roots, verify every value and child position, and distinguish exact subtree equality from partial-pattern matching.

Separate sum bits from deferred carries, preserve a finite modular sum, then decode the requested signed or unsigned result.

Return indices of the `k` largest scores in descending score order.

Count simultaneous half-open meetings, prove the minimum room count, then change endpoint occupancy or return reusable room IDs.

Share prefix work across words, restore board cells, consume unique outputs, then change board ownership or count occurrences.

Return the indices of two numbers that add to the target.

Count disjoint final moves while one rolling row retains old-above and new-left values.

Place distinct values at their frequency coordinates, then change memory use or specify exact cutoff ties.

Check whether two strings contain the same letters with the same counts.

Repair one irrelevant endpoint at a time, preserve matched outer pairs, and distinguish per-character lowercase from normalization and one-deletion edits.

Check whether all brackets close in the correct order.

Carry every ancestor's ordering constraint as an interval, reject a hidden descendant violation, and change traversal or duplicate placement deliberately.