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.

The textbook answer is the chain rule. The senior answer is what backprop is doing as a system: a reverse-mode auto-diff pass that reuses intermediate computations to get all gradients in one extra forward-cost pass.

The right answer is a procedure, not a number. The wrong answers are 'use the default' and 'try a few values.'

The loss is the objective. Picking the wrong one means optimizing for the wrong thing, no matter how well you train. The senior answer derives the loss from the problem, not from a list.

The math is identical to most candidates: penalty terms in the loss. The senior signal is the Bayesian interpretation, the optimization geometry, and when each is the right choice.

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.

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

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

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

How VAEs propagate gradients through a sampling step. The senior answer explains the why (you can't differentiate through a sample) and the how (move the randomness outside the parameters).

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.

A live coding question with a paste of buggy training code. The senior signal is the order in which you find bugs and what your debugging procedure looks like.

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.

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

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.

Fraud has the worst data of any ML problem: heavily imbalanced, biased labels, adversarial actors, and direct money on the line. The senior answer respects all four.

Most ML systems fail silently. Monitoring is what tells you. The senior answer monitors data, model, and outcome layers separately.

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

Select a primary outcome, guardrails, diagnostics, and decision horizon without turning the dashboard into a metric zoo.

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.

A senior experimentation question about objective mismatch, leakage, serving skew, feedback loops, and disciplined diagnosis.

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.

Class weighting and SMOTE are the textbook answers and often the wrong ones. The senior answer matches the technique to the imbalance ratio, the cost asymmetry, and the metric you actually care about.

The 'tell me how you'd debug' question is a behavioral round in disguise. The interviewer is probing your debugging instinct, not testing facts.

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

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.

Adam usually trains faster but in some settings finds sharper minima with worse generalization. The senior answer names the regimes where this happens and the modern fixes.

The architecture decision space is large: model choice, context retrieval, IDE integration, evals. The senior answer scopes the use case before any of it.

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

Healthcare adds three constraints on top of normal LLM deployment: regulatory compliance, low tolerance for harm, and a workflow that already has clinicians as the final decision-maker.

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.

A level-defining question. The same words elicit a junior, senior, or staff answer. The rubric below shows the differences.

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.

The most-asked LLM design question of 2026. The answer is a decision tree, not a preference.

A simple-sounding feature with deep recsys ground underneath. The senior answer chooses between item-item collaborative filtering, embedding similarity, and learned co-purchase models, with explicit handling of feedback loops.

A multi-shelf, multi-objective recommendation surface. The senior answer scopes the shelves first, then designs each as its own ranker with a meta-layer above.

The canonical recsys design question. The real test is whether you'll dive into model architecture or scope the problem first.

Cold-start is solved by combining minimal explicit signal, demographic and contextual fallbacks, and aggressive exploration in the first few sessions.

Search ranking eval is offline metrics for development, A/B for shipping, and human raters for absolute calibration. The senior answer uses all three and respects what each measures.

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.

Most of recsys hasn't changed; LLMs add new capabilities at specific stages. The senior answer names which stages benefit and which don't.

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

A strong mission answer names competing goods, makes a costly choice, exposes uncertainty, and shows what evidence changed your behavior.

The senior signal here is that you have an explicit prioritization framework, not just a list of interests. The L6 answer connects user value, technical leverage, and team strategy.

Scoping is the single most important senior skill. The interview tests whether you have a process, not just a definition.

A senior project presentation should expose three decisions, one failure, honest attribution, and enough depth to survive interruption.

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.

A trap question that rewards taste. Strong opinions, defended with reasoning, are the senior signal. Weak opinions or 'I don't know' both lose.