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.

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

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

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.

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.

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.

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

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.

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.

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.

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

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.

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.

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 deep recommendation case balancing viewer value, creator opportunity, quality, revenue, concentration, experimentation, operations, and portfolio choices across a short-form video ecosystem.

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 a core senior skill. The interview tests how you reduce ambiguity before choosing a model or system design.

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.

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

Infer character order from words that are sorted in an unknown alphabet.

Check whether the child heights at every node differ by at most one.

Buy once, then sell later. Return the largest profit.

Compute precision and recall from binary labels and predictions.

Find a target in a sorted array.

Return tree values one level at a time.

Find the largest sum of any connected path in a binary tree.

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

Count ways to reach step `n` using moves of one or two steps.

Make a deep copy of a connected graph.

Find the fewest coins needed to make an amount.

Return combinations that add to a target. A value may be used more than once.

Count ordered sequences of values that add to the target.

Rebuild a binary tree from its preorder and inorder value lists. Values are unique.

Pick two heights that hold the most water.

Check whether any value appears more than once.

Count subarrays that contain exactly `k` odd numbers.

Return the set-bit count for every value from 0 through `n`.

Check whether all courses can be completed.

Return one valid order for completing every course.

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`.

Count ways to decode digits where `1` through `26` map to letters.

Store words and support `.` as a wildcard that matches any one character.

Find the fewest insert, delete, or replace steps needed to change one string into another.

Convert a list of any strings into one string and recover the exact list.

Add numbers one at a time and return the current median.

Find the smallest value in a sorted array that was rotated once.

Check whether undirected edges form one valid tree.

Put words with the same letters into the same group.

Find the most money that can be taken without choosing neighboring houses.

Houses form a circle, so the first and last houses are neighbors.

Support word insert, full-word search, and prefix search.

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

Swap the left and right children at every node.

Check whether jumps can reach the last array position.

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

Find the `k`th largest value in an unsorted array.

Return the `k`th smallest tree value.

Find the largest rectangle that fits under histogram bars.

Check whether a linked list contains a cycle.

Find the longest sequence of characters that appears in two strings in the same order. Characters do not need to be next to each other.

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

Find the longest path that moves to a larger neighboring value each step.

Find the longest strictly increasing subsequence. Values do not need to be next to each other.

Return the longest continuous palindrome in a string.

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

Find the longest substring with no repeated character.

Find the lowest node whose subtree contains both target nodes.

Support `get` and `put` in constant time. Remove the least recently used item when the cache is full.

Find the number of nodes on the longest root-to-leaf path.

Find the largest product of a nonempty continuous subarray.

Find the largest sum of a nonempty continuous subarray.

Check whether one person can attend every meeting.

Find the smallest number of rooms needed for all meetings.

Merge every pair of overlapping ranges.

Merge many sorted linked lists into one sorted list.

Merge two 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.

Find the shortest substring that contains all required characters and counts.

Values come from 0 through `n`, with one missing. Return the missing value.

Find when a signal from one node reaches every node in a weighted directed graph.

Find the fewest ranges to remove so the rest do not overlap.

Count the set bits in an integer.

Count separate groups in an undirected graph.

Count connected groups of land in a grid.

Find cells whose water can reach both oceans.

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 every continuous palindrome in a string.

Check whether the values can be split into two groups with equal sums.

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

Return every possible ordering of the input values.

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

Find the edge that creates a cycle in an undirected graph.

Remove the `n`th node counted from the end.

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

Reverse the 32 bits of an unsigned integer.

Reverse all links in a singly linked list.

Rotate a square matrix 90 degrees clockwise in place.

Find how many minutes all reachable fresh oranges need to rot.

Check whether two binary trees have the same shape and values.

Find a target in a sorted array that was rotated once.

Convert a tree to text and rebuild the same tree from that text.

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

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.

Return every subset of the input values.

Check whether one full tree appears inside another tree.

Add two integers without `+` or `-`.

Return the `k` values that appear most often.

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

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

Count paths from the top-left to bottom-right when moves can only go right or down.

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

Ignore punctuation and letter case, then check whether text reads the same both ways.

Check whether all brackets close in the correct order.

Check whether every node follows all BST ordering rules.

Check whether a string can be split into dictionary words.

Check whether a word can be formed by neighboring board cells without reusing a cell.

Find every dictionary word that can be formed on a letter board.