Meta AI Engineer interview questions

Attention is permutation-invariant, so with no position information a transformer cannot detect word order. The signal is knowing why, and why the field shifted from absolute sinusoidal encodings to relative ones like RoPE and ALiBi that extrapolate to longer contexts.

Embeddings are the foundation of modern NLP and retrieval. This tests whether you grasp the distributional idea behind them, not just 'words become vectors.' What matters is how training on context yields geometry that encodes meaning.

Offline metrics gate releases; online metrics reveal what actually happened with users. What shows depth is understanding why offline wins routinely fail to hold up online, and how the two feed each other.

Cross-attention is how a model attends from one sequence into another, the mechanism behind encoder-decoder models and multimodal conditioning. What shows depth is knowing exactly where the queries versus keys/values come from.

Full attention is O(n^2), so long context demands cheaper attention. What shows depth is naming the families (sparse, sliding-window, linear), what each surrenders, and why FlashAttention is not one of them.

Modern LLMs abandoned learned absolute positions for RoPE and ALiBi to cope with long context. The signal is recognizing that both encode RELATIVE position, and precisely how that permits length extrapolation past the trained window.

MQA and GQA shrink the KV cache, the thing that bottlenecks LLM serving. The signal is understanding they share key/value heads across query heads to trim memory and bandwidth, with GQA as the quality-preserving middle ground. Here is the answer.

Scaling laws explain why bigger models trained on more data predictably improve, and Chinchilla changed how we allocate compute. The signal is the model-size-vs-data tradeoff and the fact that many models were under-trained. Here is the answer.

How you decode from the model's probabilities shapes the output as much as the model itself. The signal is knowing the deterministic vs sampling methods and where each fits (factual vs creative). Here is the answer.

BERT and GPT diverge on one decision made before a single weight is trained: what does each token get to see? That choice ripples into attention, use case, and why one family now dominates. Here is the answer.

Multilingual models are uneven across languages, and most candidates cite only the obvious cause. The differentiator is the tokenizer: the same sentence can cost a non-English user several times as many tokens. Here is the answer.

A transformer emits one vector per token, but retrieval needs one vector per text. The signal is knowing the pooling options and the catch nearly everyone overlooks: the model has to be trained for whichever one you pick.

Both are conditional compute, but one scales parameters and the other scales depth. The signal is knowing which axis each routes along and why that shifts the FLOP story. Here is the sharp version.

RAG and fine-tuning get cast as either/or. RAFT trains the model to be good at RAG itself. The tell is what goes into the training set: relevant docs mixed with distractors. Here is the answer.

Distillation gives you most of a frontier model's quality for a fraction of the serving cost. The signal is naming the three LLM-specific variants and knowing which one holds up against a closed API. Here is the answer.

A few thousand carefully chosen examples can beat a million scraped ones. The signal is knowing which filters matter, how you gauge example quality, and why diversity beats raw volume.

GRPO drops the value model and estimates advantage from a group of samples per prompt. The signal is the exact mechanics, why the group baseline works, and the normalization traps that silently bias training.

Swap a learned reward model for a checker that returns right-or-wrong, and reward hacking largely vanishes. The signal is why verifiable rewards beat learned ones for math and code, and where they break.

Distillation is not a single method. The signal is knowing when to match logits versus train on generated text, why on-policy distillation beats off-policy, and how reasoning models are distilled.

The proportions of web, code, books, and math in pretraining quietly set downstream skills. The signal is knowing how mixtures get chosen, why upsampling helps, and how methods like DoReMi automate it.

Continued pretraining adds domain knowledge that fine-tuning cannot, yet done carelessly it wrecks general ability. The signal is the replay ratio, learning-rate rewarming, and how you measure forgetting.

When a benchmark leaks into pretraining, the score measures memorization rather than ability. The signal is the detection methods (n-gram overlap, canaries, perturbation tests) and why fresh held-out evals matter.

Evict the oldest tokens to cap the KV cache and the model falls apart. Retain only the first few tokens and it keeps generating forever. What matters is grasping why those opening tokens behave as an attention sink.

A model trained at 4K tokens can reach 128K without a full retrain. What matters is understanding why naive extrapolation breaks and how PI, NTK-aware scaling, and YaRN each rescale RoPE frequencies in different ways.

Speculative decoding accelerates generation, and with the right verification rule it leaves the output distribution untouched. What matters is understanding how draft-model, self-drafting (Medusa/EAGLE), and lookahead approaches differ in where the guesses originate, and which of them are still exact.

FP8 underpins modern H100-class training and serving. What matters is knowing the two FP8 variants, why a floating format beats INT8 on dynamic range, and where scaling still counts.

VLMs such as GPT-4V and LLaVA attach a vision encoder to a language model through a projector. The signal is the image-tokens-as-prefix design, the alignment training, and the resolution and hallucination failure modes.

Speech LLMs either transcribe to text or model audio straight away as discrete tokens. The signal is the semantic-vs-acoustic token split and why end-to-end audio models outperform ASR-plus-LLM pipelines on latency and prosody.

Four fusion families, and the choice between them is decided by one question most candidates never ask. Naming CLIP and LLaVA is table stakes; the score comes from knowing which one cannot reason and which one eats your context window.

Every LLM is one function: tokens in, a distribution over the next token out. The signal is what you say next, because the distance from that function to a useful assistant is three training stages, and almost every production complaint lands in exactly one of them.

The shift from one model per task to one model adapted many ways rewrote the job description. The interviewer is checking whether you know which half of the work got nearly free, which half did not move at all, and which problems classical ML still owns outright.

One triangle of negative infinity, added before the softmax, is what makes transformer training parallel and generation stubbornly serial. Interviewers want the mechanism and the asymmetry it creates, not a definition of attention read back to them.

Two defaults that every Llama-class model shares and almost no candidate can justify. One is a compute win that turned out to cost nothing in quality; the other is what makes a 60-layer stack converge at all.

Most candidates answer with the 2015 ResNet answer and stop. The senior answer treats the residual stream as a shared communication bus, and that reframing is what makes logit attribution, the logit lens, and activation steering possible at all.

Three different systems are failing at once (the tokenizer, the model, and your pipeline) and most candidates blur them into one. Separating them tells you which fix buys the most, and the highest-leverage one is not the prompt.

Naming RLHF is not an answer. The frame that scores is outer versus inner alignment, why Goodhart breaks any proxy objective you optimize hard enough, and why a classifier sitting at the boundary can constrain a model's behavior without changing what it is trying to do.

Video breaks a VLM on arithmetic before it breaks it on vision: one frame per second of a ten-minute clip is hundreds of thousands of image tokens. Frame selection is not preprocessing, it is the architecture, and the strongest systems index the audio first.

A VLM is three parts and the interview is entirely about which ones you train. The staged recipe, why the vision encoder almost always stays frozen, and the silent failure where your model learns to answer from the text prior and never looks at the image.

A deceptively easy ML-coding ask. Writing exp/sum is trivial; the signal is the max-subtraction trick and the log-sum-exp form that stop it overflowing. Here is the stable implementation and the reason the naive version breaks.

The single most-asked design-coding question, and a common warm-up at the labs ahead of the ML follow-ups. The signal is the hashmap-plus-doubly-linked-list for genuine O(1), then handling the TTL and concurrency follow-ups cleanly. Here is that build.

A classic that pays off the two-heap insight. A sorted list costs O(n) per insert; two balanced heaps give O(log n) insert and O(1) median. Here is the implementation and the rebalancing detail people get wrong.

The from-scratch implementation that frontier labs and NVIDIA really do ask. Writing it shows you grasp shapes, the scale factor, the causal mask, and how heads split and recombine. Here is a correct, readable implementation plus the follow-ups.

Beam search is the decoding algorithm everyone cites and few can code correctly. The signal is keeping k hypotheses by cumulative log-prob, adding logs (not multiplying probs), and handling completed sequences and length. Here is a correct implementation and the tradeoffs.

A from-scratch ML-coding staple that tests whether you really know the math you rely on. The signal is the clean gradient (it reduces to Xᵀ(ŷ - y)/n), numerical stability, and vectorization. Here is the implementation and the details interviewers push on.

Autocomplete is the canonical trie question, and it checks whether you reach for the right structure rather than scanning a word list. The signal is O(prefix) lookup, the DFS to gather completions, and the follow-ups (ranking, memory). Here is the build.

A classic that checks whether you reach past sorting for the right structure. The signal is the heap solution (O(n log k)), the bucket-sort O(n) trick, and how it shifts for an unbounded stream. Here is the answer.

Sliding window is one of the highest-yield coding patterns, and this is its canonical problem. The real signal is spotting when a window collapses an O(n squared) scan into one linear pass, and holding the invariant cleanly.

Graph traversal sits beneath a large family of interview problems. What matters is knowing the BFS-vs-DFS tradeoff (shortest path vs memory shape) and applying it cleanly, then getting the directed-vs-undirected cycle gotcha that trips up most candidates.

DP feels like pattern-matching magic until you have a method. The signal is a repeatable drill: spot overlapping subproblems and optimal substructure, define the state and recurrence, then memoize or tabulate. Here is that method applied to a worked example.

A common ML-coding check that confirms you actually understand the metrics you quote. The signal is getting TP/FP/FN/TN right and knowing macro vs micro averaging for multiclass, not reaching for sklearn.

Data loading is where training pipelines quietly bottleneck. The signal is a correct shuffle-then-batch iterator plus knowing why prefetching and parallel loading keep the GPU fed.

Merging intervals is a staple that probes the sort-then-sweep idea. The tell is sorting by start and merging in a single pass, O(n log n). Below is the pattern along with the family of problems it opens up.

k-NN is quick to code and a solid check of vectorization and the lazy-learner tradeoff. Interviewers look for a tidy vectorized distance calculation plus knowing why naive prediction is O(n) and how to accelerate it. The implementation follows.

Coding conv2d shows you understand what a CNN layer really computes rather than just being able to name it. Interviewers watch for correct output-shape math, tidy stride and padding handling, and awareness of the im2col trick frameworks actually rely on.

LayerNorm appears in every transformer, and coding it verifies you know what it normalizes over and why. Interviewers look for normalization across the feature dimension per token, the learnable scale and shift, and the RMSNorm simplification modern LLMs took up.

Binary search is simple to explain and notoriously easy to botch (off-by-one, infinite loops). Interviewers look for a correct template plus the variants (boundaries, rotated arrays) that show up constantly. The answer follows.

Backtracking underlies permutations, subsets, N-queens, and constraint problems. Interviewers look for the choose/explore/un-choose template plus pruning, and knowing exactly which knob distinguishes permutations from combinations.

A warm-up that tests for the stack instinct. Interviewers look for recognizing that last-opened-first-closed maps onto a stack, plus handling the edge cases (leftover opens, early close). The pattern follows.

Merging k sorted sources is the textbook min-heap problem and a genuine data-engineering pattern (merging sorted shards/streams). Interviewers look for the heap of k heads yielding O(N log k). The answer follows.

A classic that pays off the two-pointer insight over brute force. Interviewers look for realizing that water at each position is capped by the min of the max walls on each side, then computing it in a single pass. The answer follows.

Coding BatchNorm verifies you know the train/inference difference, the part everyone forgets. Interviewers look for normalizing over the batch with running stats kept for inference. The implementation follows.

The textbook warm-up that tests for the hash-map instinct: swap space for time to turn O(n squared) into O(n). Interviewers look for the one-pass complement lookup. The pattern follows.

Topological sort arranges a DAG so dependencies come first, the backbone of build systems, schedulers, and ML/data pipeline DAGs. Interviewers look for Kahn's algorithm (or DFS) plus cycle detection. The answer follows.

Union-Find answers 'are these in the same group?' almost instantly and drives connected-components, cycle detection, and clustering. Interviewers look for path compression plus union by rank for near-O(1) operations. The answer follows.

A staple grid-traversal problem probing BFS/DFS flood fill and disciplined visited-marking. What interviewers watch for: viewing the grid as a graph and tallying connected components. Here is the answer.

Edit distance is the archetypal 2D string DP, powering spell-check, diff, and fuzzy matching. What interviewers watch for: naming the subproblem and the insert/delete/replace recurrence. Here is the answer.

Drawing a uniform sample from a stream too large for memory (or whose length stays unknown) is a genuine data-engineering problem. What interviewers watch for: the replace-with-decreasing-probability trick and a telescoping proof. Here is the answer.

Reversing a linked list is the archetypal pointer-handling screen. What interviewers watch for: the three-pointer walk executed without ever dropping the tail of the list, plus why the iterative version wins over recursion in production. Here is the answer.

Turning a tree into a string and reconstructing it faithfully rests on one choice most candidates overlook. Skip it and the structure turns ambiguous. Here is the answer and the interview-grade reasoning.

LCA is the recursion staple that probes how you carry information upward from subtrees in one pass. What interviewers watch for: the post-order 'found in left, found in right' logic. Here is the answer plus the BST shortcut.

Maximum subarray is the entry-point 1D DP problem, and Kadane's is the O(n) one-liner. What interviewers watch for: the 'extend or restart' call at each element and the all-negative edge case most people fumble. Here is the answer.

Word Break is the classic 1D string DP that snags people who reach for greedy or naive recursion. What interviewers watch for: the dp[i] = 'is the prefix of length i segmentable' recurrence, plus why a locally valid split can doom the rest. Here is the answer.

Rotating a matrix in place probes index manipulation and the transpose-then-reverse trick. What interviewers watch for: splitting the rotation into two simple passes instead of juggling four-way swaps. Here is the answer.

Bit-manipulation problems screen for fluency with binary and the O(1)-space tricks most candidates fumble. The tell is whether you reach for XOR's self-canceling property and the n & (n-1) idiom by reflex. Here is the toolkit.

K-th largest has three textbook solutions, and what interviewers watch for is knowing Quickselect's average O(n) beats sorting's O(n log n), why its worst case is O(n²), and when a heap is genuinely the better call. Here is the answer.

TF-IDF is the classic text-vectorization scheme and a quick test of whether you truly grasp term-frequency times inverse-document-frequency, or merely recite it. What interviewers watch for: explaining why IDF kills common words. Here is the implementation.

The DP that reveals why greedy quietly fails on non-standard denominations, and how a single bottom-up table fixes it. What interviewers watch for: the dp[amount] recurrence and the unbounded-reuse insight.

LCS is the template 2D-sequence DP behind diff tools and bioinformatics. Interviewers look for rebuilding the match/mismatch recurrence from memory and not mixing up subsequence (gaps allowed) with substring (contiguous). The answer follows.

Gas Station pays off spotting a greedy invariant that turns O(n²) into O(n). Two facts carry the whole solution: total feasibility, and that a failed prefix lets you skip every start within it.

Jump Game pays off spotting that a greedy reachability scan beats DP. Interviewers look for tracking the farthest reachable index in one pass, and catching the exact moment you fall behind it.

LIS has an obvious O(n²) DP and a clever O(n log n) solution that catches people off guard. Interviewers look for the patience-sorting/binary-search approach that maintains 'tails'. Both appear below.

Minimum Window Substring is the hard sliding-window problem that probes expand-and-contract with a character-count map. Interviewers look for the grow-to-valid then shrink-to-minimal pattern, verified in O(1) per step.

House Robber is the tidiest choose-with-a-constraint 1D DP, and it reduces to O(1) space. Interviewers look for the take-this-or-skip recurrence and the two-variable rolling optimization.

Group Anagrams probes the 'compute a canonical key and bucket by it' pattern. Interviewers look for choosing a key that anagrams share without comparing every pair. The answer follows.

Building a PR/ROC curve from scratch shows you understand thresholds and the precision/recall tradeoff. What interviewers really want is sweeping the threshold in one sorted pass and integrating the area. The implementation follows.

This problem outlaws the obvious division trick, forcing the prefix/suffix-product insight. Interviewers look for computing left and right products in two passes with O(1) extra space. The answer follows.

Sorting an array of three values in one pass probes the three-pointer partition (Dutch National Flag). Interviewers look for the low/mid/high invariant and knowing when not to advance mid. The answer follows.

Spiral traversal probes careful boundary management more than algorithmic insight. Interviewers look for shrinking four boundaries layer by layer without double-visiting a row or column. The answer follows.

The textbook grid DP where each cell depends on three neighbors at once. What interviewers want is the min-of-three recurrence, plus the reason it has to be min. The answer follows.

This notoriously hard problem demands better than the O(m+n) merge: an O(log) binary search on the partition. Interviewers look for binary-searching the split point so the left halves stay below the right halves. The answer follows.

Decode Ways is a 1D DP whose difficulty sits entirely in the edge cases: zeros and the valid 1-26 range. Interviewers look for the take-one-digit-or-two recurrence plus disciplined validity checks. The answer follows.

This classic has a tidy O(n^2) expand-around-center solution that outdoes the naive O(n^3). Interviewers look for expanding from every center and handling odd and even lengths separately. The answer follows.

Coding Adam shows you know what .step() actually does: momentum combined with per-parameter adaptive rates and bias correction. What interviewers watch for is the two moments plus the bias-correction step.

Computing the max of each size-k window the obvious way costs O(n*k). The move that cuts it to O(n) is a monotonic deque of indices, and why it stays linear catches most candidates off guard.

The fewest meeting rooms you need equals the highest number of meetings active simultaneously. That reframing is the entire interview; two O(n log n) solutions drop out of it, and the tie-handling catches careless candidates.

This one rewards knowing that an in-order walk of a BST produces sorted order. The signal is halting at the kth element instead of walking the entire tree.

A row- and column-sorted matrix rewards a single insight: begin at a corner and drop a whole row or column each step. That converts an O(m*n) scan into O(m+n), and which corner you pick is not arbitrary.

Dropout takes five lines, yet most candidates fumble two of them: turning it off at inference and rescaling the survivors so the expected activation holds constant. Inverted dropout is the convention they want to see.

Finding the longest run of consecutive integers without sorting divides candidates who reach for O(n log n) from those who spot the hash-set trick. The signal is one loop invariant that eliminates redundant work. Here is the answer.

Validating a BST trips up people who only check parent-child pairs and miss violations buried deep in a subtree. The signal is propagating min/max bounds or relying on in-order monotonicity. Here is the answer.

Course Schedule collapses to a single question: is the prerequisite graph a DAG? The signal is seeing the graph framing and applying topological sort or DFS to detect a cycle. Here is the answer.

RoPE is why modern LLMs extrapolate to longer contexts, and it works by rotation, not addition. Coding it shows you truly understand how position enters attention. Here is the implementation.

A bad split silently inflates every metric you'll ever report, and the bugs are subtle: leaked groups, shuffled time, preprocessing fit on everything. Here is the split done right.

Many state-of-the-art training runs hold a shadow copy of the weights that averages the trajectory, then serve that rather than the final step. It's a few lines and a genuine accuracy gain. Here it is.

Nearly every modern training run relies on warmup-then-cosine, and getting it wrong destabilizes early training or squanders the tail. It's a closed-form function of the step. Here is the implementation and the why.

The textbook variance formula suffers catastrophic precision loss on streaming data and cannot update incrementally. Welford's one-pass update is the norm for online feature normalization. Here it is.

Negative sampling in word2vec and recommendation pulls millions of weighted samples; running each at O(log n) becomes a bottleneck. The alias method turns each draw into O(1) after an O(n) setup. Here it is.

When you shard a vector index or route requests across model replicas, naive 'hash mod N' reshuffles everything the moment N changes. Consistent hashing moves only a small fraction. Here is the implementation.

A Bloom filter answers 'have I seen this?' with a few bits per item rather than storing the key, swapping a rare false positive for a large memory saving. Here is the build, the sizing math, and where it pays off in dedup and serving.

Floyd's tortoise and hare finds a cycle in O(1) space, but what sets strong candidates apart is the second phase: a brief distance argument that identifies exactly where the loop starts. Here is the answer and the math.

Two lists that share a tail have to intersect at a single node, but aligning their lengths without counting is the elegant move interviewers look for. Here is the two-pointer trick that cancels the lengths out, plus the answer.

The two-pass length-then-delete solution works, but the interview asks for a single pass: a gap of N between two pointers, plus a dummy head that makes deleting the real head come out for free. Here is the clean answer.

The diameter is not the tree's height, and the path does not have to pass through the root. The clean solution derives height and best path in one DFS, updating a global max at every node. Here is the answer and the subtlety candidates miss.

Preorder names the root; inorder divides the rest into left and right subtrees. The naive version is O(n squared); the strong answer uses a value-to-index map and a moving preorder pointer for O(n). Here is the answer and why both orders are required.

Negative subtrees, a path that bends through any node, and a return value distinct from the answer you track: this problem stuffs three traps into one DFS. Here is the clean O(n) solution and the reasoning that holds up under follow-ups.

The brute force runs O(n squared) nested scans. A monotonic stack solves it in one O(n) pass by holding only the candidates that can still become a future answer. Here is the pattern and why each element is pushed and popped exactly once.

The naive triple loop runs O(n cubed). Sort first, then fix one element and converge two pointers for O(n squared). The real test is deduplication: returning unique triplets without a set. Here is the clean template.

Merging intervals is the entry point to the whole interval family. The trick is sorting by start so overlaps end up next to each other, then collapsing them in one linear sweep. Here is the pattern and the sweep-line generalization behind it.

Generating then filtering costs O(2^(2n)) and wastes effort. Backtracking with two counters builds only valid strings by applying the balance rule at every step. Here is the template and why the pruning conditions are exactly right.

The words encode a partial order among characters. Convert each adjacent pair into a directed edge, then topologically sort. The traps are the prefix edge case and spotting contradictions. Here is the full solution with cycle handling.

Treat each word as a node and one-letter edits as edges: the shortest ladder becomes a shortest path in an unweighted graph, which means BFS. The detail that decides pass or fail is producing neighbors in O(26 * L) without scanning the entire dictionary. Here is the pattern.

Testing every subarray costs O(n squared). Prefix sums with a remainder-frequency map solve it in a single O(n) pass: two prefixes sharing a remainder mod k enclose a divisible subarray. The pitfall is negative remainders. Here is the clean answer.

Working out arithmetic with precedence and nested parentheses is a parsing task, and a single stack manages both neatly. The traps are operator precedence, multi-digit numbers, and the sign of truncated division. Here is a one-pass solution.

The rotting-oranges family of build screens: a state expands outward one step per tick across a grid, with the spec adding rules each round. The signal is multi-source BFS processed by layers, not per-cell loops. Here is the design that absorbs each new test case.

A Fenwick tree serves prefix-sum queries and point updates in O(log n) using one flat array and a single bit trick. The signal is the lowbit operation and why it wins over a plain prefix array when values change. Here is the answer.

A segment tree serves any associative range query (sum, min, max, gcd) with point or range updates in O(log n). The signal is the recursive split into covered, disjoint, and partial nodes, plus lazy propagation for range updates. Here is the answer.

Floyd-Warshall computes shortest paths between every pair of nodes in O(V cubed) with a compact three-line triple loop. The signal is the intermediate-node DP order and why k has to be the outer loop. Here is the answer.

KMP matches a pattern in linear time by precomputing a failure function that skips redundant comparisons rather than backtracking the text. The signal is what the prefix function actually holds and why the text pointer never moves backward. Here is the answer.

Rabin-Karp slides a fixed-width hash across the text so each window costs O(1) to update, which makes it ideal for matching many patterns at once. The signal is the polynomial rolling hash, modular arithmetic, and why you still verify on a hash hit. Here is the answer.

Matrix exponentiation evaluates linear recurrences like Fibonacci at index n in O(log n) by raising a transition matrix to the nth power through binary exponentiation. The signal is building the transition matrix and squaring it. Here is the answer.

A from-scratch classic that checks recursion plus the split criterion math. The signal is computing impurity correctly, picking the best threshold by information gain, and knowing the stopping rules. Here is a clean recursive implementation.

A from-scratch favorite that probes linear algebra fluency. The signal is centering first, using SVD instead of forming the covariance matrix, and reading variance off the singular values. Here is the implementation and the details interviewers push on.

A build-it-yourself check on the EM algorithm and soft clustering. What matters is the pair of alternating steps (responsibilities, then weighted re-estimation), log-sum-exp for numerical stability, and seeing how GMM extends k-means. The code follows.

A build-it-yourself check on recurrent forward passes and backprop through time. What matters is the shared-weight recurrence, summing gradients over timesteps, and articulating the vanishing-gradient problem. The code follows.

A build-it-yourself check on gated recurrence. What matters is wiring the forget/input/output gates and candidate correctly, keeping cell state distinct from hidden state, and explaining why the additive cell path cures vanishing gradients. The code follows.

A build-it-yourself check on modern optimizers. What matters is the moment estimates, bias correction, and the single change that counts: AdamW decouples weight decay from the gradient rather than folding it into the loss. The code follows, plus why it wins.

A build-it-yourself check on how learning-rate schedules are actually computed. What matters is correct closed-form formulas, knowing when each schedule shines, and why decaying the rate aids convergence. Below is the implementation of the common ones.

A build-it-yourself check on how PyTorch actually works under the hood. What matters is assembling a computation graph during the forward pass, local derivatives per op, and a topological-order backward pass that accumulates gradients. Below is a minimal engine.

A build-it-yourself check on subword tokenization. What matters is greedy longest-match encoding against a fixed vocabulary, the continuation-prefix convention, and how WordPiece diverges from BPE. The code follows.

A build-it-yourself check on distributed input pipelines. What matters is partitioning data across workers with no overlap and no gaps, epoch-consistent shuffling with a shared seed, and handling the uneven-last-batch problem. The code follows.

A 22-point AUC jump is both an opportunity and a red flag. Weaker candidates cheer; sharp ones grow wary and know precisely which leakage checks belong before anything ships.

The most frequent ML fundamentals question, and a subtle seniority check: anyone can repeat the definition, but can you break down the error and convert it into a concrete debugging plan?

The interviewer wants to see whether you choose metrics to fit the problem or just recite definitions. The signal that counts is recognizing when accuracy and even AUC mislead, and linking each metric to a decision.

Shipping a model is itself an experiment, and this question tells apart people who run A/B tests from those who p-hack them. The signal is pre-registering the metric, sizing the test, and holding back from peeking.

Imbalance turns up in fraud, churn, and abuse, and the naive answer (oversample, done) leaks data and inflates offline metrics. The signal is favoring cost-sensitive learning, fixing the metric, and resampling correctly. Here is the full toolkit with its tradeoffs.

A standard stats question that also works as a numeracy check. The signal is linking MLE/MAP to regularization and getting the base-rate calculation right, the one that surprises most people. Here is the intuition along with the worked numbers.

Optimizer questions probe whether you grasp what each one adapts and the subtle AdamW fix that the whole field now relies on. The signal is the per-parameter adaptivity story plus why tying weight decay to Adam was a bug. Here is that answer.

Tabular ML is won on features, and this question checks whether you navigate the practical traps: target leakage in encodings, informative missingness, and fitting transforms on the wrong data. The signal is leakage-safe preprocessing. Here is the toolkit.

Recsys underpins half of applied ML, and this question checks whether you fit the approach to data availability and hold a real answer for the cold-start problem that breaks naive systems. Here is the foundations answer.

A point-estimate win on a metric is not a genuine win. The signal is testing significance with the right paired method on a clean held-out set, weighing effect size, and confirming online. Here is how to compare models without fooling yourself.

A near-universal ML fundamentals question. Anyone can recite 'L1 is lasso, L2 is ridge'; the signal is the gradient-and-geometry reason L1 forces weights to exactly zero and when you'd choose each. Here is that answer.

Ensembles dominate tabular ML, and this question tests whether you grasp that they attack different parts of the error. The signal is bagging-reduces-variance vs boosting-reduces-bias and why GBMs win on tabular data. Here is the answer.

Trees are the building block of the ensembles that rule tabular ML, so interviewers check you can explain how a split gets chosen and how a lone tree overfits. The Gini-vs-entropy part is a trap: candidates over-weight a choice that barely matters. Here is the answer.

Backprop is the algorithm that makes deep learning trainable, and the interviewer wants the chain-rule mechanics, not just 'it computes gradients.' What interviewers reward is the forward-then-backward flow and why it is efficient. Here is the answer.

BatchNorm is one of the most-asked deep-learning questions, and the trap is the train/inference difference. What interviewers reward is what it normalizes, why it stabilizes and speeds training, and why it switches to running statistics at inference. Here is that answer.

This question connects why deep nets were hard to train with the cluster of tricks that solved it. What interviewers reward is the multiplicative-gradient cause and naming the real fixes: ReLU, He/Xavier init, residuals, normalization. Here is the answer.

CNNs remain foundational even as transformers rise, and this checks whether you grasp why convolution suits images. What interviewers reward is parameter sharing and local connectivity, what pooling buys, and how the receptive field grows. Here is the answer.

Patches as tokens, global attention from layer one, and a weaker inductive bias than a CNN. What interviewers reward is naming the data regime where each architecture wins and why. Here is the answer interviewers score highest.

Forward noising is fixed, reverse denoising is learned, and the training loss is a plain noise-prediction regression. What interviewers reward is why that beats a GAN's minimax and what the VAE and U-Net each do in latent space. Here is the answer.

Senior DS loops test causal reasoning beyond the randomized A/B test. What interviewers reward is naming the quasi-experimental method that fits and stating the single assumption it lives or dies on. Here is the answer for when randomization is off the table.

A model can rank perfectly and still output meaningless probabilities. The signal is knowing precisely when calibration matters, how to measure it, and the post-hoc fixes. Here is the answer most candidates miss.

Core statistics screening that catches people who run tests without grasping why they work. The signal is what the CLT actually licenses, and a correlation-vs-causation answer that uses Simpson's paradox to expose a confounder.

Self-supervision is how modern models pretrain on unlabeled data, the engine behind LLMs and modern vision. The signal is the pretext-task idea and the genuine difference between contrastive and masked-prediction objectives.

Multimodal is now table stakes, and this tests whether you understand how images and text reach a shared model. The signal is CLIP's contrastive alignment and how modern VLMs feed image features into an LLM's token space.

Sequence models remain interview staples, particularly the gating that repaired RNNs and the reason attention took over. What matters is linking the vanishing-gradient narrative to the parallelism case that let transformers ride the scaling wave.

GANs shaped generative modeling for years, and interviewers look for the minimax game, the failure modes (mode collapse, instability), and the exact reason diffusion overtook them for images while GANs still lead on speed.

Autoencoders and VAEs sit beneath representation learning and generative modeling, including the VAE inside latent diffusion. What matters is the difference between a plain autoencoder and a variational one, and why sampling blocks backprop without the reparameterization trick.

Transfer learning is the reason you seldom train from scratch, and the real question is how much of the pretrained model to reuse versus adapt. What matters is a clean decision grid across data size and task similarity, plus knowing when a low LR guards against catastrophic forgetting.

Two simple classifiers that keep showing up in interviews because they check whether you grasp assumptions and tradeoffs, not just sklearn calls. What matters is k-NN's laziness and curse of dimensionality against Naive Bayes' independence assumption. Here is the answer.

Distribution questions check whether you can map a data-generating process to the right model. What matters is knowing what each distribution describes plus a concrete use case, not memorizing PDFs. Here is the practical map.

Hypothesis testing sits under every experiment, and what matters is reading the p-value correctly (it trips most people) and picking the right test. Here is the rigorous, plain-language answer.

Labels are the costly bottleneck in ML, and these two techniques tackle it from different angles. What matters is knowing active learning picks what to label while semi-supervised draws on unlabeled data directly. Here is the answer.

Time series breaks the usual ML assumptions: data is ordered and correlated, so random cross-validation silently leaks the future and inflates your score. What matters is decomposition, point-in-time features, and time-aware validation.

Ensembles win Kaggle and quietly drive most production tabular models. What matters is explaining why combining models beats one (error decorrelation), and knowing exactly how the four techniques differ in what they fix.

A bandit learns and optimizes at the same time, moving traffic toward the winning arm during the experiment rather than holding the split fixed like an A/B test. Interviewers look for the explore-exploit tradeoff, the three core algorithms, and a clear sense of when a bandit wins over a clean A/B test.

Outlier detection appears in data cleaning, fraud, and monitoring, and no single method wins everywhere. Interviewers want you to match the statistical, distance, or model-based families to the dimensionality, distribution, and labels you actually have.

One model, multiple objectives, a single shared backbone. Interviewers want you to explain precisely why sharing helps (regularization, data efficiency) and the failure mode that wrecks naive setups. Here is the answer.

The learning rate is the single hyperparameter that can NaN your run at step 50 or stall it indefinitely. Modern training schedules it rather than pinning it to one value. Interviewers want you to know precisely what warmup and decay each give you. Here is the answer.

Ranking is not classification, so accuracy is the wrong instrument. What you need to show is matching the rank-aware metric to the task: one right answer versus many, binary versus graded relevance. Here is the answer.

A staple that tests whether you know why ReLU displaced sigmoid and how to pair the output activation with the loss. What matters is telling the vanishing-gradient story correctly. Here is the answer.

Everyone says 'gradient descent,' but the batch-size decision and momentum are the actual interview content. What earns credit is the noise-vs-cost tradeoff across batch/SGD/mini-batch and why momentum pays off.

The loss sets what the model optimizes, and the wrong choice silently sinks it. What counts is matching the loss to the task and data (outliers, imbalance), rather than reflexively reaching for MSE or cross-entropy.

Regression calls for different metrics than classification, and each tells its own story. What matters is knowing what RMSE vs MAE vs R² vs MAPE really measure and their failure modes around outliers, scale, and zeros.

Cross-validation yields a reliable performance estimate, but the wrong scheme leaks data and misleads. What matters is matching the CV scheme to the data (stratified, grouped, time-series) and fitting preprocessing inside the fold.

These three get lumped together, yet they answer different questions: one is a preprocessing tool, two are eyeballing tools. The candidates who pass know precisely which structure each keeps and which it silently discards.

k-means is the reflex answer, yet it silently assumes round, equal-size clusters and requires you to know k in advance. What earns credit is positioning each alternative by the specific assumption it drops, and knowing when to use it.

LDA is the supervised cousin of PCA, and the contrast is a favorite. What matters is knowing that LDA uses the labels to maximize class separation while PCA only chases variance, plus the C minus 1 dimension cap that trips up most candidates.

These four quantities sit under cross-entropy loss, decision-tree splits, distillation, and the KL penalty in RLHF. What matters is deriving them from one another and pointing to precisely where each turns up in a real training loop.

Preprocessing quietly decides whether a model trains well, and the right choice depends on the model. What matters is knowing when scaling counts versus when it is wasted effort, and how to encode a feature with thousands of categories without blowing up your matrix.

Bad initialization makes deep nets fail to train at all, with activations that vanish or explode through depth. What matters is knowing why zero init is fatal and how to match Xavier or He to your activation function.

High-dimensional data breaks the intuitions and methods that work in two or three dimensions. What matters is naming the concrete effects (distances concentrate, data goes sparse, overfitting climbs) and the mitigations that actually move the needle.

Feature selection trims noise, overfitting, and serving cost, but the three method families pull in different directions. What interviewers want is filter vs wrapper vs embedded and the conditions under which you reach for each.

XGBoost and LightGBM win most tabular problems, and interviewers want more than 'it's boosting.' What matters is the fit-to-residuals mechanism plus the engineering (regularization, histograms, second-order) that makes it both fast and accurate.

Pick the wrong distance metric and you quietly break kNN, clustering, and retrieval. What matters is knowing what each metric actually measures and matching it to the data: magnitude vs direction, sets, correlated features.

Contrastive learning is how modern embeddings (CLIP, sentence encoders, SimCLR) are actually trained. What matters is the pull-positives-push-negatives objective, the InfoNCE loss, and why the number and hardness of negatives makes or breaks quality.

Dropout is the classic neural-net regularizer, but what matters is whether you can explain why zeroing activations forces redundancy, and the train-vs-inference scaling bug that trips most candidates. Here is the answer.

Hand-labeling at scale is the bottleneck. Weak supervision produces labels programmatically instead, and what matters is whether you can explain how a label model denoises conflicting sources into probabilistic labels. Here is the answer.

Grid and random search ignore past results. Bayesian optimization learns from them, and what matters is whether you can explain the surrogate plus acquisition loop and name the exact condition where the sample-efficiency is worth it. Here is the answer.

Running an A/B test is easy; running a valid one is hard. What matters is naming the traps that produce confidently wrong conclusions and the fix for each. Here is the checklist a senior experimenter carries.

GNNs power recommendations, fraud, and molecule modeling by learning over graph structure. What matters is the message-passing mechanism, why k-hop matters, and why you keep them shallow. Here is the answer.

RL sits under RLHF, robotics, and recommendation, and interviewers want the core framing. What matters is the agent-environment-reward loop and the three things that make it harder than supervised learning. Here is the answer.

Data augmentation cheaply expands training data and regularizes models, but valid transforms differ by modality. What matters is the label-preserving constraint and why text is the hard one. Here is the answer.

Two inexpensive regularizers that cure overconfident classifiers. What proves you understand them is knowing that one softens the target while the other softens the input, and precisely why gentler signals produce calibrated models. Here is the answer.

Ranking differs from regression: a wrong absolute score is acceptable, a wrong ordering is not. What shows depth is the pointwise/pairwise/listwise breakdown and why pairwise (LambdaMART) remains the practical default. Here is the answer.

Classic bias-variance predicts that larger models eventually overfit, but deep nets keep improving even after they memorize the data. What shows depth is explaining the second descent and why over-parameterized models generalize. Here is the answer.

Plenty of real problems hand you confirmed positives but never confirmed negatives, only unlabeled data. The shortcut everyone grabs quietly biases the model. What shows depth is naming the regime and its fix. Here is the answer.

Some models are multiclass out of the box; others need a wrapper to extend a binary classifier to K classes. What shows depth is knowing the three strategies and exactly when each one wins. Here is the answer.

A model can rank perfectly yet lie about its probabilities; its 0.9 may hold only 70% of the time. What shows depth is knowing the three fixes, the data size each requires, and how to measure the gap. Here is the answer.

The textbook reflex ('drop one') is usually the wrong instinct, and whether collinearity matters at all depends on your model and what you want from it. This is the answer that tells rote apart from real understanding.

Anyone can recite 'linearity and normality.' Few can say which assumption matters for predictions versus inference, how to catch a violation in a residual plot, and what to actually do about it. Here is that answer.

A pre-existing gap between your groups means randomization or instrumentation is broken, and the entire experiment is suspect. Strong candidates spot sample-ratio mismatch immediately. Here is the full diagnosis and the disciplined response.

A 92% aggregate accuracy can mask 60% on the segment that matters most. Averages are exactly where these failures stay buried. Here is how to surface them and the menu of fixes that actually map to the cause.

'The model won't train' comes down to a short list of usual suspects, each with a distinctive loss-curve signature. The shape of the curve names the bug before you touch a single hyperparameter. Here is how to read it.

When labels exist only for the cases you already acted on, the model learns a distorted world: strong offline, blind to everyone you never saw. Worse, its own decisions choose the next labels. Here is how to spot it and counter it.

Defaulting to 0.5 leaves money or safety on the table. The right cutoff comes from the cost of each error and the operating constraint, not the model. Here is how to set it deliberately.

The built-in importance scores from XGBoost can rank a random ID above a vital feature, and stakeholders will base decisions on that bar chart. Here is why default importance misleads and what a careful answer reports instead.

Two models landing at the same accuracy is common, and accuracy was rarely the deciding factor to begin with. The real tiebreakers are the ones a junior candidate leaves out. This is the checklist a staff engineer works through before shipping either one.

'The model got worse' can mean three very different things with three different fixes. Retrain a model that a pipeline bug actually broke and you just bake in garbage. Here is the order to triage it in.

Most real datasets carry wrong labels, and they quietly cap your accuracy. Hand-cleaning all of it does not scale. Here is how to surface the bad labels and train robustly around them.

The notion that models, like students, learn better starting from easy examples is intuitive, and it sometimes works and sometimes does nothing. Knowing when it pays off is the real signal. Here is the honest answer.

Metric learning succeeds or fails on the pairs you feed it. Random negatives teach almost nothing, and the margin plus the mining strategy determine whether the embeddings are any good. Here is how the choices interact.

Boxes and labels, not a single tag per image. The signal is picking two-stage versus one-stage from your latency and accuracy budget, knowing what NMS and anchors really do, and reporting mAP correctly. Here is the answer interviewers score highest.

Cross-entropy is where you start, not where you finish. The signal is fitting the loss to the task structure: focal for detection's background flood, the IoU family for box overlap, Dice for imbalanced masks. Here is how to reason about it.

Semantic labels every pixel by class; instance pulls each object apart. The signal is knowing that the first cannot count overlapping objects, why Mask R-CNN adds a mask branch on RoIAlign, and what RoIAlign fixed. Here is the answer.

A million rows does not automatically call for deep learning. The signal is reasoning from dimensionality, data type, inference latency, and label budget, then noting where KNN quietly lives on as approximate nearest neighbor. Here is the answer.

Resampling, reweighting, and focal loss tackle class imbalance from different angles, and each carries a real downside. The signal is matching the method to the model and metric, not blindly oversampling. Here is the breakdown.

IV is the causal tool people name but cannot defend. The signal is spelling out the two conditions an instrument must meet, why one is testable and one is not, and what 2SLS actually estimates. Here is the answer.

Propensity scores promise to imitate an experiment from observational data. The signal is knowing what they can and cannot fix, the overlap trap, and why IPW blows up. Here is the answer that sets careful candidates apart.

CUPED can halve the sample size an A/B test requires without touching validity. The signal is explaining why subtracting a pre-experiment covariate reduces variance yet never biases the estimate. Here is the answer.

Standard A/B math assumes one user's treatment does not affect another's outcome. In marketplaces and social networks that assumption breaks and your estimate is biased. The signal is naming SUTVA and the right randomization unit. Here is the answer.

Prophet treats forecasting as curve-fitting trend plus seasonality plus holidays, rather than as a stochastic process. The signal is knowing why that design wins on business data and where it quietly fails. Here is the answer.

Fairness has no single number, and a well-known result proves the main three cannot hold together. What interviewers reward is defining each metric precisely and explaining the impossibility rather than picking one blindly. Here is the answer.

Most teams run human eval as a vibe check with ten examples and a 1-5 slider. The signal is treating it as a designed experiment: pairwise, blinded, powered, and agreement-measured. Here is the protocol that survives scrutiny.

A model that never looks at the image can score respectably on VQA, which tells you most of what you need to know about the benchmark. Here is what the scores hide, and the one-line ablation that exposes it.

An eval suite that never varies the image will happily pass a model that has stopped looking at it. Start with the modality ablation, then pick metrics by what the system actually produces. Here is the full stack.

Sessionization tells apart candidates who reach for a self-join from those who know LAG plus a running sum. Below is the two-pass pattern that holds up across billions of events, along with the edge cases interviewers press on.

Pipelines fail and retry, so the real question is whether a retry corrupts your data. What interviewers look for is idempotent writes (not 'exactly-once delivery') alongside watermarks for late data. Here is how to keep re-runs safe without double-counting.

Top-N-per-group is the window-function question every data round asks, and the trap is RANK vs ROW_NUMBER vs DENSE_RANK. What interviewers want is picking the right ranking function for ties and understanding window frames. Here is the pattern and the tie nuance.

A hard streaming-systems question: dedup at high throughput while keeping state bounded. What interviewers reward is a tiered state design (a probabilistic filter ahead of durable state) plus watermark-driven eviction. Here is the architecture that does not OOM.

A pipeline-design question that rewards fitting the architecture to the freshness requirement rather than chasing real-time for its own sake. What interviewers want is the latency-vs-complexity tradeoff and an understanding of why Kappa arose to kill Lambda's dual codebase. Here is the decision.

A data-warehouse fundamentals question that tells apart people who model for analytics from those who only know OLTP normalization. What interviewers listen for is facts vs dimensions, the star schema, and why analytics denormalizes where transactional systems normalize.

What separates a query that scans a terabyte from one that scans a gigabyte is usually layout, not the engine. Interviewers listen for partition pruning, columnar formats, and the small-files problem.

Keeping a warehouse in sync with a live OLTP database is a CDC problem, and the naive 'full reload nightly' or 'query by updated_at' answers leave real gaps. The signal is log-based CDC and idempotent merges.

Bad data quietly corrupts everything downstream (dashboards, models, decisions), and 'it ran without error' is not the same as 'it's correct.' The signal is the categories of checks and failing loud at the boundary.

Query tuning is a core data-engineering skill, and what interviewers watch for is reading the execution plan before you change anything, then applying the right fix. Here is the diagnostic method that tells guessers apart from engineers.

Dedup is a daily data-engineering task and a frequent screen. The signal is ROW_NUMBER to keep the right record (not just DISTINCT), pinning down what 'duplicate' actually means, and handling near-duplicates at scale.

Pivoting (rows to columns) shows up constantly in analytics and reporting, and the portable trick is conditional aggregation, not a vendor PIVOT clause. The signal is the CASE-inside-aggregate pattern and knowing its one real limit.

The classic product-analytics SQL question. The signal is grouping users by signup cohort, deriving each activity's period offset, and counting distinct returners per offset to build the retention triangle.

Joins are the core of SQL, and the real signal is precise semantics: semi/anti joins (EXISTS / NOT EXISTS), the NOT IN null trap, and the fan-out bug that quietly doubles your sums.

The subtle part of rolling aggregates is the window frame clause, especially ROWS vs RANGE. The signal is the right frame for a moving window and the tied-rows gotcha that corrupts running totals.

Means mislead on skewed data like latency and spend, and SQL ships dedicated functions for the truth. The signal is PERCENTILE_CONT/DISC for exact quantiles, NTILE for bucketing, and why p50/p99 beat the average.

A new column is safe; a rename quietly corrupts every dashboard downstream. The signal is knowing which changes stay compatible, enforcing data contracts in CI, and running expand-contract migrations for the breaking ones.

You cannot wait for all the data, and buffering an unbounded stream will OOM. The signal is windowed joins with watermarks for stream-stream, lookup joins for stream-table, and a clean account of late and out-of-order events.

Set operations and NULL semantics catch out even senior engineers. The signal is UNION vs UNION ALL and its dedup cost, plus three-valued logic where NULL matches nothing, not even itself.

The number-one cause of mysteriously slow Spark jobs: one partition handles most of the work while the rest idle. The signal is reading the symptom (a few straggler tasks) and reaching for the right fix, salting, broadcast, or AQE.

Time-based analysis runs through all of analytics, and time zones and bucketing are the usual traps. The signal is DATE_TRUNC for bucketing, interval math, and storing UTC.

Correlated subqueries read naturally but may run once per row (O(n squared)), a classic slow-query cause. The signal is spotting them and rewriting as joins or window functions.

Reporting frequently needs subtotals and grand totals across several dimensions, and stitching that together with many UNIONs wastes work. The signal is GROUPING SETS, ROLLUP, and CUBE in one pass.

Exact COUNT(DISTINCT) over billions of rows has to track every unique value, so it turns slow and expensive. The signal is knowing when a sketch like HyperLogLog buys huge memory and speed wins for a sub-percent error budget.

The most frequent way SQL leaks the future into a training set is a sloppy join to a feature table. The fix is point-in-time correctness, implemented as an as-of join. Here is how to write it.

Funnels seem like plain counts until you demand the steps occur in order and within a window. Tallying each step on its own overstates conversion. Here is the ordered-funnel query.

Consecutive-run problems (active streaks, uptime windows, price-stable periods) all boil down to one trick. Once the row-number difference clicks, they collapse to a window function and a group-by.

Building a training set from a billion-row table means sampling, and the naive 'ORDER BY random() LIMIT n' sorts the whole table. Stratified sampling takes even more care. Here are both, done efficiently.

Bucketing converts a skewed continuous feature into something a model (or a report) handles well, and the choice between equal-width and equal-count bins changes everything on skewed data. Here is both in SQL.

Production drift monitoring frequently lives in the warehouse, not a fancy tool. Comparing two distributions in SQL with a metric like PSI is a few CTEs. Here is how to compute it.

An org-chart recursion walks a tree, but a general graph has multiple paths and back-edges. The signal is building up the visited path to prune cycles and ranking paths by cost to land the shortest one.

Plenty of candidates know only 'use Debezium.' The signal is comparing three CDC mechanisms on how each captures deletes, loads the source, and preserves ordering, plus the snapshot-to-stream stitching that trips up real deployments.

Anyone can say 'filter and dedup.' The signal is the funnel arranged by cost, the MinHash/LSH banding math, and recognizing that the shuffle across billions of documents is what actually runs up the bill, plus the benchmark decontamination people forget until their eval numbers get challenged.

Two problems wear one costume here: how you would have caught this before full rollout, and how you debug it after the fact. Cover both and you show senior judgment. This walks through the staged-rollout and root-cause playbook.

The most common ML system design round. Interviewers reward the funnel structure: candidate generation, then ranking, then re-ranking, with the right model at each stage plus an honest plan for cold start, freshness, and feedback loops. This lays out that structure.

Severe class imbalance, a tight latency budget, and an adversary who keeps adapting. What interviewers watch for: treating imbalance honestly, setting the operating point from costs, and building for the feedback loop. This covers the end-to-end design.

Models fail silently, so the real question is whether you would notice. What interviewers look for: watching the right layers (operational, data, prediction, outcome) and alerting on drift without drowning in false pages. This covers the system and the metrics that count.

Multimodal search checks whether you grasp shared embedding spaces and the retrieve-then-rank pattern under a real catalog's scale and freshness. What interviewers reward: CLIP-style joint embeddings, hybrid retrieval, and honest relevance evaluation. This lays out the design.

Moderation is a multi-stage classification problem with harsh tradeoffs: false negatives cause real harm, false positives silence legitimate users, and the adversary keeps adapting. What interviewers reward: the tiered pipeline, per-severity precision/recall calibration, and human-in-the-loop. This lays out the design.

Ads ranking is where calibrated probabilities collide with tight latency and money. The signal is knowing that CTR has to be calibrated (not just ranked), the feature and serving design, and the auction context. Here is the design that goes past 'train a classifier.'

Screening resumes is both high-volume and high-stakes: a legally sensitive, bias-prone judgment about people. The signal is trading off throughput against fairness, human oversight, and explainability, not an LLM ranking resumes. Here is the design.

Dynamic pricing combines demand forecasting, optimization, and real-time serving, under fairness and trust constraints. The signal is the predict-then-optimize structure plus guardrails against perverse outcomes. Here is the design.

E-commerce search is where retrieval, ranking, and business goals meet, and it carries a strict exact-match requirement (brand, size, SKU). The signal is query understanding plus hybrid retrieval plus business-aware ranking. Here is the design.

A GPU-heavy generative-audio system with text/genre/lyric conditioning, minutes-long coherence, and copyright constraints. The signal is the generation pipeline plus the async, cost, and safety layer that gets it shippable.

Video generation is image generation plus the harsh constraint of temporal consistency, and it is the most GPU-intensive generative task around. The signal is diffusion over spacetime plus a serving design that holds up under multi-minute jobs.

Notification systems fail by spamming users until they mute, and a mute is a permanently lost channel. The signal is treating it as a per-user send/hold/batch/suppress decision optimized for long-term trust, not for clicks or volume.

How large recommenders and search draw candidates from millions of items in milliseconds. The signal is why the user and item towers stay separate, how that enables precomputed embeddings plus an ANN index, and where ranking takes over.

Every keystroke has to return ranked suggestions in tens of milliseconds, at search-engine QPS. The interesting part is the data structure and what you precompute, not the query path. Here is the design that holds up under the latency budget.

PYMK is graph recommendation at billion-node scale. The interviewer is testing for one instinct: do you generate candidates from the social graph, or naively try to score every pair? Here is the design that holds up through the follow-ups.

Feed ranking is multi-objective ML at massive scale with a harsh serving constraint. The interviewer wants to see whether you optimize a value model toward long-term satisfaction, or fall into the CTR trap that breeds clickbait. Here is the design.

Predict, value, and bid on one impression in roughly 10ms, billions of times a day. The signal is the pCTR-to-bid pipeline under a tight latency budget, plus why calibration and budget pacing decide whether you make or lose money.

Image search is embedding retrieval at billion-image scale. A strong answer shows when a vision-only encoder is enough and when you need a CLIP-style shared space, plus how the ANN index actually serves the query. Here is the design.

Spam detection is adversarial, imbalanced classification under a low-latency bar. The interviewer is watching whether you set the threshold by cost asymmetry and rely on signals spammers cannot fake. Here is the design.

Query understanding is the front end of search that converts a raw query into structured intent. Get it wrong and even a perfect index returns garbage. The signal is the pipeline and how you measure it. Here is the design.

Online models need features that are fresh and computed the same way training computed them. The classic failure is training-serving skew that quietly degrades the model. The signal is the online/offline split built on one shared definition. Here is the design.

New users and new items carry zero interaction history, so collaborative filtering has nothing to work with. The candidates who pass treat it as a lifecycle, not a single trick. Here is how.

Machine translation is seq2seq generation delivered across hundreds of language pairs under strict latency and quality budgets. What matters is sidestepping the quadratic pair blowup, saving low-resource languages, and serving it cheaply. Here is the design.

Detecting walking, driving, or a fall from a sensor stream is windowed time-series classification, typically on a battery-bound device. What matters is windowing, temporal smoothing, and the on-device constraints most candidates overlook. Here is the design.

Matrix factorization is the classic collaborative-filtering method and the conceptual seed of modern embedding-based recsys. What matters is the latent-factor idea and how it leads to two-tower/neural models.

Recommending events (or jobs) breaks ordinary recsys in two spots: items expire and items are local. What matters is how you handle perishability, geography, and the fact that every item is a cold-start item. Here is the design.

Tagging articles at scale is bread-and-butter ML, but the naive version fails three ways: it is multi-label, the taxonomy is hierarchical and keeps growing, and rare classes hide behind aggregate accuracy. What matters is the model choice plus how you handle all three.

A recommender trains on data its own past recommendations produced, so it learns to confirm its own beliefs. What matters is spotting the loop, naming the biases it breeds, and knowing the exploration and debiasing fixes that break it.

Labeled data is the fuel for ML, and a labeling platform succeeds or fails on quality control. The signal is the workflow plus the quality math: consensus, gold honeypots, inter-annotator agreement, and active learning to spend the budget where it counts.

Detecting and boxing objects at scale reduces to one driving tradeoff plus a handful of CV specifics most candidates fumble: the detector family, NMS, focal loss, and why mAP rather than accuracy is the metric. Here is the design.

Classic distributed-systems tradeoffs appear in ML infra with an ML twist: stale features and eventually-consistent reads carry model-accuracy consequences, not just correctness ones. Here is how to reason about it.

Anthropic's signature opener. The naive answer (one server pushes to N clients) is capped by the source uplink and scales linearly. The answer interviewers reward turns receivers into senders so the swarm's capacity grows with its size. Here is that reasoning.

The Dynamo question. Interviewers want three decisions made cleanly: how you partition keys so adding nodes does not reshuffle everything, how you replicate for durability, and where you sit on the CAP spectrum. Here is how to reason through all three with concrete quorum math.

Looks simple until the follow-ups: which layer do you balance at, how do you keep traffic off a dead server, and how does the load balancer itself avoid being a single point of failure? Interviewers want the algorithm, the health-check loop, and the high-availability story.

A deceptively rich warm-up. The interesting calls are how you mint short, collision-free, unguessable keys at scale, and how a read-heavy 100:1 workload shapes storage and caching. Here is the clean design with capacity math.

The observability infrastructure question. Interviewers want you to split the three telemetry types, choose storage that withstands massive write volume, and design alerting that fires fast without burying on-call in noise. Here is the pipeline with retention and cardinality math.

The distributed ordering problem that sits at the heart of Kafka, replicated logs, and consensus systems. Interviewers look for you to face the uncomfortable fact that physical clocks lie, then pick the right instruments: a single sequencer, consensus, or logical clocks. This walks that progression.

The real-time messaging staple. Interviewers look for the delivery path (persistent connections, not polling), a fan-out strategy that survives large groups, and a clear story on ordering and delivery guarantees. This lays out that design, including the fan-out tradeoff that marks senior candidates.

This asks you to design the scoreboard, not the player. A strong answer keeps offline gates (AUC, calibration, NDCG) apart from the online verdict (A/B with revenue, user, and advertiser guardrails), and layers in counterfactual replay so you can trust a model before it ever serves a live auction.

A news feed differs from a generic recommender. Time is a first-class signal: a story that mattered this morning is noise by tonight. The interviewer expects recency decay, an engagement-versus-quality value model, and a plan for filter bubbles, not merely retrieval plus ranking.

Truth is not a label you can gather cheaply, and adversaries adapt as soon as you ship. A strong answer combines content, graph, and behavioral signals, places humans in the loop where precision matters, and treats adversarial drift as a permanent operating condition rather than a one-time training problem.

Video search is image search plus a time axis, and the time axis is the whole problem. A strong answer embeds frames, pools them into scene vectors, indexes with ANN at billion scale, and explains how a multimodal query (clip, text, or both) locates the right moment, not just the right video.

Moderating billions of items a day with an LLM on each one is too slow and too expensive. Learn the tiered funnel (cheap classifier then LLM then human), how to tune thresholds for precision versus recall, and how to stay ahead of adversaries.

Personalizing an LLM is a retrieval and memory problem, not a per-user fine-tune. Learn how to assemble user context at request time, keep long-term memory from bloating the prompt, and respect privacy and the right to be forgotten.

Live speech-to-speech translation is a latency race across three models (recognize, translate, synthesize) as audio keeps streaming in. See the streaming pipeline, how to commit partial results without flip-flopping, and the tradeoff between latency and translation quality.

A celebrity posts and 50M followers need a notification. The tricky parts are not sending one message; they are fan-out strategy, deduplication, channel routing, and not flooding users. Here is the architecture that handles both the long tail and the viral spike.

A cache is easy until you spread it across many nodes. Then come consistent hashing, eviction policy, the thundering herd on a cache miss, hot keys, and how much staleness you can tolerate. Here is the design that holds up under real traffic.

Crawling a few pages is trivial. Crawling the web means a URL frontier with priority, per-host politeness, dedup across billions of URLs, and defenses against spider traps and infinite content. Here is the crawler architecture that scales without getting your IPs banned.

Showing the top 10 is easy. Showing a player their global rank among 50M others, updated live, is the real challenge. The answer turns on the right data structure, sharding, and approximate ranks for the long tail. Here is how leaderboards scale.

When a page loads, an ad slot goes to auction across dozens of bidders and a winner is picked before the page finishes rendering, all in under 100ms. The design covers the auction mechanism, the brutal latency budget, budget pacing, and fraud. Here is how an exchange runs millions of auctions per second.

You cannot review a live stream after publishing, because it already reached the audience. The broadcast delay buffer is the design, and everything else (frame sampling, the audio channel, the cascade) is built to fit inside it. Here is how it fits together.

The root cause is not a weak system prompt. A model trained to be agreeable is dangerous to a user in crisis, because the objective and the safety requirement point in different directions. The fix has to live outside the model. Here is what that architecture looks like.

A classifier trained on one culture's annotations does not generalize to another culture's speech, and the aggregate metric hides it. The signal is recognizing that the ground truth itself is the bug, then designing the policy and eval stack around that.

A dependable experiment platform goes well beyond splitting traffic in half. What matters is stable assignment, exposure logging, statistical discipline, and guardrails that hold up against peeking and sample-ratio mismatch. Here is the design.

Models can only be as good as their labels, and noisy annotation quietly caps performance. What interviewers want is a measured quality process, not a bigger collection effort. Here is the answer.

Same model, two answers: clean offline, ugly online. The cause is almost always a feature computed differently across the two paths. Here is the diff-based hunt that localizes it to a single column.

A fraud model fed a feature an hour behind is half-blind, but recomputing everything in real time wastes money you don't need to spend. Freshness is a per-feature decision on a real cost curve. Here is how to manage it.

Waiting on labels to measure accuracy means learning a model broke a month after it did. Production monitoring must function before the truth shows up. These are the signals you track instead.

A data engineer renames a column and three production models quietly begin scoring on garbage. Features form a shared contract, and altering them demands the same care as a breaking API change. Here is the discipline it takes.

An alert that fires nonstop gets muted, and a model that fails with no alert is worse still. Good ML alerting is a design problem sharing SRE's principles, with ML-specific twists on top. Here is how to get it right.

Every team rebuilds a spreadsheet of training runs and then drowns in it. The interviewer wants the platform that ingests runs, params, metrics, and artifacts at high write volume, ties them together by lineage, and makes thousands of experiments comparable, which is a different system from a model registry.

Three drifts get casually lumped together, but they differ in detectability and in their fixes. What interviewers want is knowing which you can catch without labels and which one genuinely demands a new model.

You cannot wait for ground truth to tell you the model broke. Prediction-side monitoring catches failures in minutes, not weeks, provided you know which output signals actually move first.

ML incidents are trickier than service outages: nothing crashed, the model was just wrong. The strong answer covers detection, mitigation, and a blameless postmortem that fixes the system, not the person.

Production usage can become your best source of training data, or a self-reinforcing trap. What matters is knowing how to capture clean feedback and how to break the loops that quietly corrupt the model.

Fairness is a property of the model and the data it meets, so it drifts even when the weights never change. Treating it as a monitoring problem exposes three things a one-off audit never has to solve: noisy small slices, multiple comparisons, and labels that arrive months late.

FSDP and ZeRO let you train models too large for one GPU without splitting the compute. The signal is the ZeRO stages (what gets sharded at each level) and the communication you pay for it. Here is the answer.

Distributed training is bottlenecked by GPU-to-GPU communication, and these collectives are how the data travels. The signal is what each one does and which parallelism strategy relies on it. Here is the answer.

Activations, not just weights, can dominate training memory, and gradient checkpointing is the standard remedy. The signal is the precise trade: recompute activations in the backward pass rather than storing them. Here is the answer.

Batch size is a training knob whose effects on speed, memory, and generalization are non-obvious. The signal is the large-batch tradeoffs and the learning-rate-scaling and gradient-accumulation tricks that make scaling actually work.

OOM is the wall you hit most often in deep learning, and 'buy a bigger GPU' is the weakest reply. What counts is naming the memory consumers, knowing which one dominates, and pairing the right lever with it.

nvidia-smi reading 100% can mask the fact that you are tapping only a fraction of the hardware's real compute. What matters is MFU (useful FLOPs vs peak) and the gap between 'the GPU is busy' and 'the GPU is efficient'.

Past FP16/BF16, FP8 sits on the next rung of the precision ladder, and the newest tensor cores compute on it natively. What counts is knowing the two formats, what FP8 really buys, and why dynamic range demands careful scaling.

Pruning strips redundant weights to make a model smaller and sometimes faster. The signal is the structured-versus-unstructured divide and why only structured pruning dependably cuts latency on commodity hardware.

Paying for accelerators that sit idle half the time is the most common waste in ML training, and the reflex to add more GPUs only makes it worse. The interviewer wants the profiling discipline that pinpoints what is starving them.

Linear scaling is the marketing figure; the actual curve bends early for reasons rooted in physics, not bugs. Here is where the speedup leaks and how to recover it.

A 256-GPU job that freezes with no error at 3am is a special kind of pain. The causes come from a short, recurring list. Here is the systematic way to identify which one hit you.

At billion-parameter scale, training can be running smoothly and then the loss jumps and never returns, burning a fortune in compute. The causes and the playbook are familiar to the few who've done it. Here it is.

No single parallelism dimension trains a 175B model by itself. The art is stacking three of them onto the right hardware so the expensive communication stays on the fast links. Here is how to size each axis.

ZeRO and FSDP both shard training state across data-parallel ranks, but the trick is in when each shard is gathered and freed. Get the memory accounting and the all-gather timing and you can size any run.

Full activation checkpointing saves memory but costs a flat 30% extra compute. Selective recomputation wins most of that back by recomputing only the cheap, memory-heavy operations. Here is how to pick what to recompute.

The collective communication in distributed training is pure overhead unless it runs while the GPU computes. Hiding it is the difference between 30% and 55% MFU. Here is how the overlap actually works and how you check it on a trace.

MoE gives you more parameters for the same FLOPs, but the gating network, the load imbalance, and the all-to-all shuffle bring failure modes dense models never see. Here is the training playbook.

RLHF with PPO is not one model training, it is four models in the loop at once, three of them on the GPU during every step. The memory math and the generation bottleneck are what catch people out.

On a large training run a node will drop, and the interesting question is not whether but how many GPU-hours vanish when it does. Checkpoint cadence, sharded writes, and quick restart settle that.

When all-reduce is your bottleneck, the culprit is nearly always a misconfigured path: traffic on the wrong link, a dead NIC, or a topology NCCL failed to discover. Here is the methodical way to track down the missing bandwidth.

FP8 can nearly double training throughput over BF16, but with only a few mantissa bits the numerics leave no slack. Per-tensor scaling and a selective recipe are what get it to converge.

Data, tensor, and pipeline parallelism each leave a single sequence's activations on one device, so training past 200k tokens hits a wall none of them can clear. The fourth axis shards the sequence itself, and the interview turns on the communication math.

Anyone can list the engines. The signal is naming the one mechanism that distinguishes each (paged KV blocks, a radix prefix tree, ahead-of-time kernel compilation, quantized CPU inference) and picking from your traffic shape rather than a leaderboard.

Toxicity detection looks like plain text classification but is nothing of the sort: context flips labels, adversaries evolve weekly, and naive models tag dialects as hate. The signal is naming those failure modes and building the human-in-the-loop system around them.

Privacy in ML is a toolbox, not one switch, and each tool defends a different threat. The signal is mapping DP, federated learning, confidential computing, encryption, and minimization to what each one actually protects, and knowing they compose.

Deleting a row is trivial. Removing a person's influence from embeddings, caches, derived datasets, and a trained model is not. GDPR and CCPA demand it regardless. Here is the plan that survives an audit.

A backdoored model acts perfectly until it meets a secret trigger, then flips. The signal is explaining why clean test accuracy never exposes it, and what detection actually buys you when the trigger is unknown.

Gibberish-looking token strings tacked onto a prompt can reliably break refusals, and they carry over between models. The signal is explaining the gradient search that finds them and why output checks beat input pattern matching.

Epsilon is the privacy knob, and shipping DP means picking a number, justifying it, and tracking what each query spends. The signal is treating epsilon as a finite budget that composes, not a magic constant. Here is the answer.

Federated learning keeps data on-device, but you pay for it in accuracy, debuggability, and engineering complexity. The signal is naming when those costs are justified and when a simpler centralized pipeline with DP wins. Here is the answer.

Consent and retention decide whether you can lawfully train on data and how long you may hold it. The signal is purpose limitation, granular consent, enforceable TTLs, and a plan for deleting data already baked into a model. Here is the answer.

Dropping the protected attribute is the answer most candidates give, and it accomplishes nothing: the attribute is reconstructible from the features you kept. Here is how to actually locate the proxies and what removing them costs you.

Stripping direct identifiers protects nobody, because the identifying information was never in the name column. Here is how a linkage attack actually works, why k-anonymity and its patches keep failing, and the one defense that makes a promise it can keep.

Most teams stop their governance work at 'we can explain the decision.' The obligation, and the interview signal, is what happens after the user reads the explanation and says it is wrong.

Rate limits stop a user who costs you too much. They do nothing about a user doing something you forbid. The enforcement system is a different design, and interviewers can tell within a minute whether you have built one.

Picking epsilon is the easy half. The hard half is the accuracy you just gave up, and the levers that get it back are not the ones most candidates reach for.

Your guardrail reads text. The attack is not in the text. That single sentence is the whole vulnerability, and the red team you build from it looks nothing like the one you already have.

The point is not whether you failed; everyone has. Panels are probing for ownership, debugging discipline, and candor under stress. Here is the frame that turns a failure story into a hire signal, plus the pitfalls that turn it into a flag.

Every loop includes this question, and most answers slip one of two ways: too combative or too much of a doormat. The signal is evidence-based persuasion plus real disagree-and-commit. Here is the arc that connects and the traps that sink it.

Applied AI work is ambiguous by nature, and panels (Meta's 'embracing ambiguity,' Anthropic's deliberately under-specified problems) check whether you freeze or drive. The signal is structured progress under uncertainty. Here is the arc that connects.

Senior applied-AI work runs mostly on influence, not command: you need other teams to prioritize your dependency, take up your approach, or change a plan you do not own. The signal is persuading with evidence and shared goals. Here is the arc that demonstrates it.

Applied AI rarely waits for certainty, and companies (Amazon's Bias for Action, NVIDIA's speed) check whether you can act decisively without freezing or turning reckless. The signal is a reversible, well-reasoned call paired with a plan to validate. Here is the arc that connects.

Strong applied-AI engineers are the ones who refuse to reach for ML when they shouldn't. The signal is judgment: ML earns its complexity only under specific conditions, and otherwise rules and heuristics win.

Applied AI engineers who reason in business value, not just model metrics, stand out. The signal is tying the feature to a business metric, modeling total cost, and being willing to kill it. Here is the framework.

This question rewards intellectual honesty and a data-driven mindset over a polished win. The signal is running a real experiment, accepting a result you did not want, and acting on it. Here is the arc that connects at experiment-heavy cultures.

This question checks whether you can deliver under pressure without missing the date or shipping something broken. The signal is ruthless scoping and guarding quality where it matters, not all-nighter heroics. Here is the arc that connects.

Ownership is a top leadership signal: taking responsibility for an outcome no one assigned you. The signal is spotting a gap, owning it end to end including the unglamorous parts, and driving measurable impact. Here is the arc that connects.

Applied AI is persuasion backed by evidence, and this checks whether you can move a skeptic with data rather than rank or opinion. The signal is understanding their concern, bringing the exact evidence that addresses it, and speaking in their terms.

Simplification is a senior signal: anyone can add complexity, but removing it safely takes judgment. The interviewer wants a real case where you cut complexity, told essential apart from accidental, and it paid off measurably.

This probes whether you handle interpersonal friction with maturity, not who turned out right. The signal is seeking to understand the other side, anchoring on the shared goal, and keeping the relationship intact through the disagreement.

Customer obsession is Amazon's first Leadership Principle and a universal product signal. The interviewer wants evidence that you begin from the user's real need, not the technology, and push for the harder right solution over the easy one.

A depth probe dressed up as a story. They want to watch you reason through genuine difficulty and keep going when pushed three levels down. The signal is a real hard problem, a systematic attack, and a root cause you own cold.

A soft-sounding question that quietly filters out low-effort candidates and tests real fit. The signal is specific, researched reasons tied to your trajectory, not flattery. Here is the structure that lands.

This probes whether you can move quickly under uncertainty without being reckless. The signal is a calculated, reversible risk taken with judgment. Here is the arc that lands, especially at Amazon.

The way you deliver bad news reveals maturity and trustworthiness. The signal is communicating early, honestly, and with a plan, rather than hiding or sugarcoating it. Here is the arc that lands.

This probes resilience: can you push through sustained difficulty without quitting or burning out? The signal is staying the course through setbacks with adaptation, not stubbornness. Here is the arc that lands.

This tests self-awareness and growth: can you critique your own work honestly and pull out lessons? The signal is a genuine, specific improvement you'd make, owned without defensiveness. Here is the arc.

AI, ML, and GenAI engineering is cross-functional: you deliver alongside PMs, engineers, and domain experts. This question checks whether you work well across those boundaries. The signal is connecting different goals and vocabularies toward one shared outcome. Here is the arc.

The classic prompt that tests self-awareness and honesty, not a polished non-answer. What scores is a genuine weakness plus the work you're putting in to fix it. Here is how to answer it well.

Handling hard feedback well is a marker of maturity and leadership. Interviewers look for candor delivered with care that genuinely shifted behavior, not avoidance and not bluntness. Here is the arc that lands.

Real work brings more demands than time, often from stakeholders who each assume theirs comes first. This question tests how you prioritize and communicate. The signal is ordering by impact out in the open, not simply working harder.

The field advances quickly, requirements move, and tooling turns over month to month. The question tests adaptability. What scores is welcoming the change, ramping fast, and steering course productively rather than pushing back. Particularly relevant for applied AI.

Saying no skillfully is a senior marker: guarding quality, scope, or users while keeping the relationship intact. What scores is principled pushback backed by reasoning and an alternative, not a bare refusal. Here is the arc.

Choosing the right metric takes real judgment, and in AI the offline number and true impact regularly diverge. What scores is a metric anchored to outcomes and protected against gaming. Here is the arc.

The 2025-2026 AI-fluency screen. Interviewers look for a concrete daily workflow, a real verification discipline, and a story where the AI was wrong. Vague enthusiasm fails; here is what passes.

The opener in half of all Applied AI screens, and most candidates answer it with a definition nobody scores. The distinction that actually earns points is about where you start and what your bottleneck turns out to be.

With billions of candidate items and only tens of milliseconds to choose the next 10, a feed is a latency problem first. The interview probes the two-stage architecture, how you set the objective when engagement fights integrity, and the biases that silently corrupt your training labels.

Training a pCTR model is the easy part. The challenge is proving a change helps before it reaches revenue, when the model runs inside an auction, the logs surface only ads that won, and a 1% calibration error costs real money. This is an eval question, not a model question.

The positive class runs about 1 in 1,000, your labels show up late and noisy, and the instant you ship a model the adversary starts probing it. This is the uncommon ML problem where the data actively fights back, so the design hinges on labels, latency, and enforcement cost as much as on the classifier.

This model's output is a price input, not a ranking. A miscalibrated CTR skews the auction bid, so you overpay or underdeliver. Throw in conversions that arrive days after the click and advertisers with no history, and calibration plus delayed feedback become the entire interview.

This product succeeds or fails on a feedback loop measured in seconds: every swipe is a label, and the following video must respond to it. The tricky part is exploring widely enough to learn what someone enjoys while avoiding a filter bubble or the amplification of junk.