Google Applied AI Engineer interview questions

Almost everyone can quote softmax(QKᵀ/√d_k)V. The interviewer wants the variance argument and the exact training failure the scale prevents. Here is the answer that separates memorization from understanding.

The single most-asked applied GenAI question, and the one most candidates answer as a definition dump. The interviewer wants a decision framework with a default and the conditions that flip it. Here is the call that scores.

A clean fundamentals question that catches people who only know GPT. The signal is matching the architecture to the task by its attention pattern, and explaining why the field consolidated on decoder-only even for non-generation tasks. Here is that answer.

Tokenization looks like plumbing until it explains your bill, your latency, and why the model fumbles numbers and rare languages. The signal is knowing how subword tokenizers work and the consequences that fall out of them.

MoE is why some frontier models have huge parameter counts but serve cheaply. The signal is the sparse-activation idea, the routing mechanism, and the operational cost (memory, load balancing) that the FLOP savings quietly hide.

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

These are the knobs every LLM product tunes, and the interviewer wants to know what each does to the probability distribution and which setting fits which task. Including why factual and creative tasks want opposite settings.

Evaluation is the hardest, most underrated part of shipping LLMs. The signal is knowing why public benchmarks mislead, why LLM-as-judge is biased, and how to build a task-specific eval you actually trust.

Embeddings are the substrate of modern NLP and retrieval. This checks whether you understand the distributional idea behind them, not just 'words become vectors.' The signal is how training on context produces geometry that encodes meaning.

Perplexity is the classic LM metric. The signal is knowing it is just exponentiated cross-entropy, what it intuitively measures, and why a low perplexity does not mean a good product.

In-context learning is the property that made prompting a paradigm; chain-of-thought is its most useful trick. The signal is knowing what 'learning' means here (no weight updates) and why making the model reason step by step actually helps. Here is the answer.

Two prompting strategies that buy accuracy with extra compute. The signal is knowing how each explores the reasoning space, that they trade tokens and latency for reliability, and how to decide when the problem actually warrants it. Here is that answer.

ReAct is the pattern behind most tool-using agents. The signal is why interleaving reasoning with actions (and observing results) beats reasoning alone or acting alone. Here is the answer that connects the prompt pattern to real agent behavior.

The 2025-2026 landscape isn't 'bigger is better' anymore. The signal is knowing why small models and reasoning models exist, the test-time-compute tradeoff, and routing the right model to the right task. Here is the practitioner's view.

Jailbreaking is the adversarial sport of routing a model around its own safety training. The signal is naming the technique families and treating defense as a layered, never-finished arms race, not a one-time patch.

Instruction tuning is what turns a raw next-token predictor into something that follows instructions. The signal is placing it correctly in the pretrain to SFT to alignment pipeline and knowing exactly what it does and does not fix.

Fine-tune a model on your domain and it can forget how to do everything else. The signal is explaining why shared weights cause it and naming the concrete mitigations that all reduce to one principle.

PEFT is a family, not just LoRA, and interviewers probe whether you know how each one injects trainable parameters. The signal is where each method adds capacity and the latency and quality tradeoffs that follow.

The classic automatic metrics for generated text. Interviewers want you to match each to its task and name the blind spot they all share. The candidates who pass say why none of them is the final word on quality.

Everyone quotes benchmark scores; few read them honestly. The signal is naming what each probes and why leaderboard numbers run ahead of real-world ability. The follow-up the interviewer is holding back is how you would detect contamination.

LLM-as-judge is how you grade open-ended generation at scale, and G-Eval formalized it. The signal is naming the biases that make raw judge scores untrustworthy and showing exactly how you harden them.

Offline metrics gate releases; online metrics tell you what actually happened with users. The signal is knowing why offline wins routinely fail to hold 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. The signal is knowing exactly where the queries vs keys/values come from.

Everyone fixates on attention, but the feed-forward layers hold most of a transformer's weights and do much of the per-token 'knowledge' work. The signal is knowing what the FFN computes and why it dominates the parameter count.

Context windows are not arbitrary numbers; they fall out of attention's quadratic cost, KV-cache memory, and how the model was trained. The signal is naming all three causes and matching each to the technique that extends it.

Full attention is O(n^2), so long context needs cheaper attention. The signal is naming the families (sparse, sliding-window, linear), what each gives up, and why FlashAttention is not one of them.

RLAIF and Constitutional AI swap human preference labels for AI-generated ones to scale alignment. The signal is naming exactly what they substitute for human feedback, and the consistency-versus-bias tradeoff that swap creates.

Reasoning models are the 2025-2026 frontier. The signal is knowing they are trained (largely via RL on verifiable rewards) to produce long internal reasoning, and that they scale on a second axis: spending more compute at inference.

Tool calling powers every agent. The signal is knowing the model executes nothing: it emits a structured request your code runs, then you feed the result back. Here is the loop and the details that decide reliability.

Modern LLMs dropped learned absolute positions for RoPE and ALiBi to handle long context. The signal is knowing both encode RELATIVE position, and exactly how that enables length extrapolation past the trained window.

MQA and GQA shrink the KV cache, the thing that bottlenecks LLM serving. The signal is knowing they share key/value heads across query heads to cut 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 get better, and Chinchilla changed how we allocate compute. The signal is the model-size-vs-data tradeoff and 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. The signal is knowing the deterministic vs sampling methods and when each fits (factual vs creative). Here is the answer.

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

Prompting for JSON works until it doesn't, and at scale the tail breaks your parser. Constrained decoding makes malformed output literally unsamplable. The signal is knowing exactly where in the loop the constraint bites. Here is the answer.

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

Combine several fine-tunes into one model by doing arithmetic on their weights, with no retraining and no data. The signal is knowing why it works and which method to reach for when merges interfere.

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

Chain-of-thought looks like the model showing its work, but it may not reflect the real computation. The signal is knowing CoT can be a post-hoc story, with evidence, and what that breaks for safety and oversight.

Preventing hallucinations is one job; catching the ones that slip through at runtime is another. The signal is the detection toolkit, why each signal is imperfect, and how you combine them into an action.

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 changes the FLOP story. Here is the sharp version.

Hand-tuned prompts break on the next model upgrade and don't compose across pipeline stages. Frameworks like DSPy compile prompts against a metric instead. The signal is treating prompting as an optimized program. Here is the answer.

A model advertising a million-token window may not use it. The signal is knowing needle-in-a-haystack, where it breaks, and how to test real multi-fact reasoning across the full context. Here is the answer.

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

One trained embedding you can truncate to any length and still use. The signal is the nested-prefix training objective and the coarse-to-fine retrieval win it unlocks at scale. Here is the answer.

Optimize any proxy hard enough and the model finds the exploit, not the goal. Sycophancy, padding, and fake citations are reward hacking. Here is why it happens and the controls that actually hold.

Few-shot accuracy can swing on example order alone. If your prompt is fragile to things that shouldn't matter, the fix is structural, not lucky example-hunting. Here is what actually reduces variance.

CoT is not a universal upgrade. On some tasks it does nothing or hurts, and the reason tells you what to try instead. Here is the escalation ladder past 'let's think step by step'.

For open-ended generation there's no ground-truth string to match, so accuracy is meaningless. The field uses a layered mix of automatic, model-based, and human metrics. Here is how to assemble a credible eval.

Push PPO hard enough and true quality peaks then falls while the reward keeps climbing. The signal is knowing the Gold-vs-proxy gap, the KL budget that bounds it, and how you actually measure when to stop.

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 quietly bias training.

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

Distillation is not one 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 ratio of web, code, books, and math in pretraining quietly decides downstream skills. The signal is knowing how mixtures are chosen, why upsampling helps, and how methods like DoReMi automate it.

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

A reward model turns pairwise preferences into a scalar signal RLHF can optimize. The signal is the Bradley-Terry loss, the base-model and head choices, and how you validate it before trusting it.

RLAIF replaces expensive human labels with an LLM's preferences, which scales but inherits the labeler model's biases. The signal is how AI feedback is collected and where it quietly fails.

MQA and GQA shrink the KV cache by sharing key/value heads. MLA takes a different route: compress K and V into a low-rank latent and cache that. The signal is knowing it is a cache trick, not a head-sharing trick, and why it keeps quality.

A model trained at 4K tokens can be stretched to 128K without full retraining. The signal is knowing why naive extrapolation fails and how PI, NTK-aware scaling, and YaRN each rescale RoPE frequencies differently.

At long context the KV cache, not the weights, fills the GPU. The signal is naming the levers (quantization, token eviction, head sharing, low-rank) and what each one costs in quality.

Speculative decoding speeds up generation without changing the output distribution. The signal is knowing how draft-model, self-drafting (Medusa/EAGLE), and lookahead approaches differ in where the guesses come from.

FP8 is the format behind modern H100-class training and serving. The signal is knowing the two FP8 variants, why a floating format beats INT8 for dynamic range, and where scaling still matters.

VLMs like GPT-4V and LLaVA bolt a vision encoder onto 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 directly as discrete tokens. The signal is the semantic-vs-acoustic token split and why end-to-end audio models beat ASR-plus-LLM pipelines on latency and prosody.

Modern embedding models want a task instruction prepended to the text, and getting the prefix wrong quietly wrecks retrieval. The signal is why instructions help and the asymmetric query/passage convention.

Everyone budgets image tokens. Almost nobody budgets image latency. Images are a prefill problem, prompt caching stops paying for itself, and the cheapest answer is often not to call a VLM at all.

A VLM that reads an invoice wrong and a VLM that reads it right and reasons wrong produce the same end-to-end score, and they need opposite fixes. Here is how to decompose a multimodal eval, build the set from real traffic, and probe for the hallucinations that accuracy never catches.

Every team ships English first, then finds that the retriever, the prompt, the latency budget and the cost model each degrade differently in the next five languages. The applied playbook looks nothing like the model-level answer, and the thing that sinks launches is the eval set nobody built.

A 2025-2026 question that catches people clinging to dogma in either direction. The signal is a cost, latency, accuracy, and scale tradeoff, plus knowing the 'lost in the middle' failure of long context. Here is the framework for choosing.

Code-execution agents are powerful and dangerous: arbitrary model-generated code runs on your infrastructure. The signal is real isolation (containers/VMs), resource limits, and network/filesystem restrictions, not 'trust the model.' Here is the answer.

Real documents carry images, charts, and tables, not just text, and text-only RAG silently drops them. The signal is knowing the two retrieval approaches and why the generator must change too. Here is the answer.

A computer-use agent drives a real browser or desktop through screenshots and clicks. The signal is the perceive-decide-act loop plus the containment for an agent that can click, buy, or delete anything. Here is the answer.

Reranking is the cheapest large win in RAG quality: retrieve broadly, then reorder precisely. The signal is the bi-encoder-versus-cross-encoder distinction and the retrieve-then-rerank two-stage design. Here is the answer.

Single-shot retrieval fails on questions that chain facts ('who directed the highest-grossing film of 2019?'). The signal is decomposing or iterating retrieval instead of retrieving once, and guarding against errors compounding across hops. Here is the answer.

Late interaction gets cross-encoder-like quality with near-bi-encoder scalability. The signal is the per-token embeddings plus MaxSim matching that buys you the middle ground, and knowing what it costs. Here is the answer.

A short question and the passage that answers it live in different neighborhoods of embedding space. HyDE closes that gap by embedding a fake answer instead of the question. The signal is knowing why a wrong hypothetical still retrieves the right docs.

Standard RAG trusts whatever it retrieves, even when it's irrelevant. Corrective RAG grades retrieval quality and acts on it. The signal is the grade-then-correct loop: re-retrieve, fall back to web search, or discard.

Late interaction stores one vector per token, so a corpus that fit in a few GB as single vectors can balloon 100x. The signal is knowing the compression and indexing tricks (centroids, residuals, PLAID) that make multi-vector retrieval shippable.

A single embedding can't represent a question with three independent parts. The signal is knowing when to split a query, how to retrieve and recombine per sub-query, and the latency and drift costs that make decomposition a net loss on simple questions.

Vector search over rows is the wrong tool when the user asks for a count or an aggregate. The signal is retrieving the right schema, generating validated SQL, and knowing when to query the database instead of embedding it.

Splitting source files every 500 characters cuts functions in half and destroys retrieval. The signal is chunking on syntax, retrieving by symbol and dependency, and combining lexical exact-match with semantic search the way code search actually needs.

Linear agents commit to one path and can't backtrack. Tree-of-Thoughts and LATS add search over reasoning paths. The signal is knowing what they buy, what they cost, and when a cheaper loop wins.

Multi-agent systems coordinate through handoffs and shared state. The signal is knowing the orchestration topologies, what a clean handoff protocol carries, and why naive multi-agent often loses to one good agent.

Final-answer accuracy hides how an agent got there. The signal is trajectory-level metrics: tool-selection and argument accuracy, step efficiency, and matching against reference paths, plus when exact-match is the wrong yardstick.

Per-step accuracy looks fine, yet a 50-step task fails. The signal is understanding compounding error and the techniques (decomposition, verification, checkpointing) that keep long-horizon agents from collapsing.

Agents can critique and retry their own work. The signal is knowing how Reflexion's verbal feedback loop works, when self-critique genuinely helps versus when it is theater, and what makes it real.

Any content an agent reads can carry instructions that hijack it. The signal is knowing why filtering can't fully solve injection and which containment controls actually bound the damage when it succeeds.

Agents that drive a browser or screen fail in ways chat agents never do: stale DOM, dynamic pages, wrong clicks. The signal is the grounding and reliability techniques that turn a flaky demo into something usable.

A VLM that reads one page perfectly can still fail an 80-page contract, and the reason is arithmetic before it is model quality. The signal is picking the right architecture and knowing what per-page processing silently loses. Here is the answer.

A deceptively simple ML-coding ask. Anyone can write exp/sum; the signal is the max-subtraction trick and the log-sum-exp form that keep it from overflowing. Here is the stable implementation and why the naive one breaks.

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

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

Beam search is the decoding algorithm everyone references and few can implement correctly. The signal is keeping k hypotheses by cumulative log-prob, summing 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 checks whether you actually know the math you use. The signal is the clean gradient (it simplifies 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 tests whether you reach for the right structure instead of scanning a word list. The signal is O(prefix) lookup, the DFS to collect completions, and the follow-ups (ranking, memory). Here is the build.

The core operation under every embedding/RAG retrieval, asked as a coding exercise. The signal is vectorizing the similarity, normalizing correctly, and using a partial selection (argpartition) instead of a full sort. Here is the efficient implementation and the scaling follow-up.

A classic that tests 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 changes 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 recognizing when a window collapses an O(n squared) scan into one linear pass, and maintaining the invariant cleanly.

Graph traversal underpins a huge class of interview problems. The signal is knowing the BFS-vs-DFS tradeoff (shortest path vs memory shape) and applying it cleanly, then handling the directed-vs-undirected cycle gotcha most candidates miss.

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 on a worked example.

A common ML-coding check that verifies 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 silently bottleneck. The signal is a correct shuffle-then-batch iterator plus knowing why prefetching and parallel loading keep the GPU fed.

BPE is the tokenizer behind GPT-style models, and implementing it proves you understand how subword vocabularies are built, not just that they exist. The signal is the iterative merge of the most frequent adjacent pair.

Interval merging is a classic that tests the sort-then-sweep insight. The signal is sorting by start, then merging in one pass, O(n log n). Here is the pattern and the family of problems it unlocks.

k-NN is simple to write and a good test of vectorization and the lazy-learner tradeoff. The signal is a clean vectorized distance computation and knowing why naive prediction is O(n) and how to speed it. Here is the implementation.

Implementing conv2d proves you understand what a CNN layer actually computes, not just that you can name it. The signal is correct output-shape math, clean stride/padding handling, and knowing the im2col trick frameworks really use.

LayerNorm sits in every transformer, and implementing it checks that you know what it normalizes over and why. The signal is normalizing across the feature dimension per token, the learnable scale/shift, and the RMSNorm simplification modern LLMs adopted.

Implementing the KV cache proves you understand why decode is efficient: you append the new token's K/V and reuse the rest instead of recomputing. The signal is the append-and-attend-over-cache logic. Here is the implementation.

Binary search is easy to describe and famously easy to get wrong (off-by-one, infinite loops). The signal is a correct template plus the variants (boundaries, rotated arrays) that come up constantly. Here is the answer.

Backtracking is the pattern behind permutations, subsets, N-queens, and constraint problems. The signal is the choose/explore/un-choose template plus pruning, and knowing exactly which knob separates permutations from combinations.

A warm-up that screens for the stack instinct. The signal is recognizing last-opened-first-closed maps to a stack, and handling the edge cases (leftover opens, early close). Here is the pattern.

Merging k sorted sources is the canonical min-heap problem and a real data-engineering pattern (merging sorted shards/streams). The signal is the heap of k heads giving O(N log k). Here is the answer.

A classic that rewards the two-pointer insight over brute force. The signal is realizing water at each position is bounded by the min of the max walls on each side, then computing it in one pass. Here is the answer.

Implementing BatchNorm checks that you know the train/inference difference, the part everyone forgets. The signal is normalizing over the batch with running stats maintained for inference. Here is the implementation.

The canonical warm-up that screens for the hash-map instinct: trade space for time to turn O(n squared) into O(n). The signal is the one-pass complement lookup. Here is the pattern.

Topological sort orders a DAG so dependencies come first, the backbone of build systems, schedulers, and ML/data pipeline DAGs. The signal is Kahn's algorithm (or DFS) plus cycle detection. Here is the answer.

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

A grid-traversal classic that tests BFS/DFS flood fill and the visited-marking discipline. The signal is treating the grid as a graph and counting connected components. Here is the answer.

Edit distance is the canonical 2D string DP, behind spell-check, diff, and fuzzy matching. The signal is defining the subproblem and the insert/delete/replace recurrence. Here is the answer.

Sampling uniformly from a stream you cannot fit in memory (or whose length you never learn) is a real data-engineering problem. The signal is the replace-with-decreasing-probability trick and a proof that telescopes. Here is the answer.

Reversing a linked list is the canonical pointer-handling screen. The signal is the three-pointer walk done without ever losing the rest of the list, plus knowing why the iterative version beats recursion in production. Here is the answer.

Encoding a tree into a string and rebuilding it exactly hinges on one decision most candidates skip. Miss it and the structure becomes ambiguous. Here is the answer and the interview-grade reasoning.

LCA is the recursion classic that tests how you propagate information up from subtrees in a single pass. The signal is the post-order 'found in left, found in right' logic. Here is the answer plus the BST shortcut.

Maximum subarray is the gateway 1D DP problem, and Kadane's is the O(n) one-liner. The signal is the 'extend or restart' decision at each element and the all-negative edge case most people botch. Here is the answer.

Word Break is the classic 1D string DP that trips people who reach for greedy or naive recursion. The signal is 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 tests index manipulation and the transpose-then-reverse trick. The signal is decomposing the rotation into two simple passes rather than juggling four-way swaps. Here is the answer.

Bit-manipulation problems screen for comfort 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 on instinct. Here is the toolkit.

K-th largest has three textbook solutions, and the signal 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 actually the better call. Here is the answer.

TF-IDF is the classic text-vectorization scheme and a fast check of whether you actually understand term-frequency times inverse-document-frequency, or just recite it. The signal is explaining why IDF kills common words. Here is the implementation.

The DP that exposes why greedy quietly breaks on non-standard denominations, and how one bottom-up table fixes it. The signal interviewers want is the dp[amount] recurrence and the unbounded-reuse insight.

LCS is the template 2D-sequence DP behind diff tools and bioinformatics. The signal is reconstructing the match/mismatch recurrence cold and not confusing subsequence (gaps allowed) with substring (contiguous). Here is the answer.

Gas Station rewards 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 inside it.

Jump Game rewards spotting that a greedy reachability scan beats DP. The signal is tracking the farthest reachable index in one pass, and detecting the exact moment you fall behind it.

LIS has an obvious O(n²) DP and a clever O(n log n) solution that surprises people. The signal is the patience-sorting/binary-search approach maintaining 'tails'. Here is both.

Minimum Window Substring is the hard sliding-window problem that tests expand-and-contract with a character-count map. The signal is the grow-to-valid then shrink-to-minimal pattern, checked in O(1) per step.

House Robber is the cleanest choose-with-a-constraint 1D DP, and it collapses to O(1) space. The signal is the take-this-or-skip recurrence and the two-variable rolling optimization.

Group Anagrams tests the 'compute a canonical key and bucket by it' pattern. The signal is choosing a key that anagrams share without comparing every pair. Here is the answer.

Building a PR/ROC curve from scratch proves you understand thresholds and the precision/recall tradeoff. The real signal is sweeping the threshold in one sorted pass and integrating the area. Here is the implementation.

This problem bans the obvious division trick, forcing the prefix/suffix-product insight. The signal is computing left and right products in two passes with O(1) extra space. Here is the answer.

Sorting an array of three values in one pass tests the three-pointer partition (Dutch National Flag). The signal is the low/mid/high invariant and knowing when not to advance mid. Here is the answer.

Spiral traversal tests careful boundary management more than algorithmic insight. The signal is shrinking four boundaries layer by layer without double-visiting a row or column. Here is the answer.

The canonical grid DP where each cell depends on three neighbors at once. The signal interviewers want is the min-of-three recurrence, and the reason it has to be min. Here is the answer.

This famously-hard problem wants better than the O(m+n) merge: an O(log) binary search on the partition. The signal is binary-searching the split point so the left halves stay below the right halves. Here is the answer.

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

This classic has a clean O(n^2) expand-around-center solution that beats the naive O(n^3). The signal is expanding from every center and handling odd and even lengths separately. Here is the answer.

Implementing Adam proves you understand what's happening under .step(): momentum plus per-parameter adaptive rates with bias correction. The signal is the two moments and the bias-correction step.

Single-head attention is common; multi-head adds the split-into-heads, attend-per-head, concatenate structure. The signal is the reshape into heads and a clear reason why multiple heads help. Here is the implementation.

Finding the max of every window of size k naively is O(n*k). The trick that drops it to O(n) is a monotonic deque of indices, and the reason it stays linear surprises most candidates.

The minimum number of meeting rooms equals the peak number of meetings running at once. The reframing is the whole interview; two O(n log n) solutions fall out of it, and the tie-handling trips up the careless.

This problem rewards knowing that an in-order traversal of a BST yields sorted order. The signal is stopping early at the kth element rather than traversing the whole tree.

A row- and column-sorted matrix rewards one observation: start from a corner and kill an entire row or column each step. That turns an O(m*n) scan into O(m+n), and the choice of corner is not arbitrary.

Dropout is five lines, yet most candidates botch two of them: disabling it at inference and scaling the survivors so the expected activation stays constant. Inverted dropout is the convention they want to see.

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

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

Course Schedule reduces to one question: is the prerequisite graph a DAG? The signal is spotting the graph framing and using topological sort or DFS to detect a cycle. Here is the answer.

Comparing every pair of a million documents is a trillion comparisons. MinHash estimates Jaccard similarity from a tiny signature, and LSH turns dedup into a near-linear scan. Here is the implementation.

RoPE is why modern LLMs extrapolate to longer contexts, and it's a rotation, not an addition. Coding it shows you actually understand how position enters attention. Here is the implementation.

Many state-of-the-art training runs keep a shadow copy of the weights that's a moving average of the trajectory, and serve that instead of the final step. It's a few lines and a real accuracy boost. Here it is.

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

Before transformers, this was the language model, and it is still the cleanest way to show you understand what perplexity actually measures. Smoothing is the part people get wrong. Here is the implementation.

Negative sampling in word2vec and recommendation draws millions of weighted samples; doing each in O(log n) is a bottleneck. The alias method makes each draw O(1) after an O(n) setup. Here it is.

A Bloom filter answers 'have I seen this?' using a few bits per item instead of storing the key, trading a rare false positive for a huge memory win. Here is the build, the sizing math, and where it pays off in dedup and serving.

Floyd's tortoise and hare detects a cycle in O(1) space, but the part that separates strong candidates is the second phase: a short distance argument that pinpoints exactly where the loop begins. Here is the answer and the math.

The diameter is not the tree's height, and the path need not pass through the root. The clean solution computes 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 splits the rest into left and right subtrees. Doing it naively 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 that differs from the answer you track: this problem packs three traps into one DFS. Here is the clean O(n) solution and the reasoning that survives follow-ups.

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

The naive triple loop is 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 gateway to the whole interval family. The trick is sorting by start so overlaps land 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 is O(2^(2n)) and wasteful. Backtracking with two counters builds only valid strings by enforcing the balance rule at every step. Here is the template and why the pruning conditions are exactly right.

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

Words are nodes, one-letter edits are edges, and the shortest ladder is a shortest path in an unweighted graph, so BFS. The make-or-break detail is generating neighbors in O(26 * L) without scanning the whole dictionary. Here is the pattern.

Checking every subarray is O(n squared). Prefix sums plus a remainder-frequency map does it in one O(n) pass: two prefixes with the same remainder mod k bracket a divisible subarray. The trap is negative remainders. Here is the clean answer.

Evaluating arithmetic with precedence and nested parentheses is a parsing problem, and a stack handles both cleanly. The traps are operator precedence, multi-digit numbers, and the sign of truncated division. Here is a single-pass solution.

The canonical multi-round build screen: a simple key-value store that grows new requirements every stage (TTL, transactions, scans). The signal is not stage 1, it is whether your code absorbs stage 4 without a rewrite. Here is how to design for it.

A classic build screen: a key-value store where writes inside a transaction can be committed or thrown away, and transactions nest. The trap is mutating the base store directly. Here is the overlay-stack design that makes rollback O(1).

A practical build screen: turn a stream of sampled call stacks into a flame tree, then report self-time vs total-time per function. The trap is conflating the two times. Here is how to aggregate the tree and rank the hot functions.

A grounded systems-coding screen: find files with identical content across a tree. The naive all-pairs hash is wasteful. The signal is the size prefilter and a cheap-hash gate before the full hash. Here is the layered approach.

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

Sierra's signature build screen: cells hold values or formulas referencing other cells, and editing one must recompute its dependents without infinite loops. The signal is the dependency graph plus cycle detection. Here is the topological-eval design.

Google's 'vibe coding' screen: the spec is deliberately vague and changes mid-interview. The signal isn't the algorithm, it's whether you clarify before coding, structure for change, and keep tests green while the requirements move. Here is how to run that loop.

A Fenwick tree answers prefix-sum queries and point updates in O(log n) with a single flat array and one bit trick. The signal is the lowbit operation and why it beats a plain prefix array under updates. Here is the answer.

A segment tree answers 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.

Dijkstra finds single-source shortest paths in O((V+E) log V) with a min-heap, the backbone of routing and network latency problems. The signal is why it needs non-negative weights and how lazy deletion keeps the heap simple. Here is the answer.

Bellman-Ford handles negative edge weights that break Dijkstra and detects negative cycles, the basis of currency-arbitrage problems. The signal is the V-1 relaxation rounds and the extra Vth round that flags a negative cycle. Here is the answer.

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

Kruskal builds a minimum spanning tree by sorting edges and adding the cheapest that does not form a cycle, using union-find for the cycle check. The signal is the greedy cut property and why disjoint-set is the right tool. Here is the answer.

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

Rabin-Karp slides a fixed-width hash over the text so each window costs O(1) to update, making 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.

Binary search on the answer solves minimize-the-maximum and capacity problems by guessing the result and checking feasibility in a monotone predicate. The signal is spotting monotonicity and writing a clean feasibility function. Here is the answer.

Sieving primes, fast modular power, and Euclid's gcd are the number-theory primitives that quietly power crypto, hashing, and combinatorics problems. The signal is the O(n log log n) sieve and O(log e) binary exponentiation. 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 via binary exponentiation. The signal is building the transition matrix and squaring it. Here is the answer.

A time-based key-value store records versioned writes and answers 'what was the value at time t' via binary search over per-key timestamps. The signal is the append-only design and the floor (largest timestamp <= t) lookup. Here is the answer.

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

A from-scratch staple that checks whether you understand the conditional-independence assumption and why you work in log space. The signal is fitting per-class means and variances, summing log-likelihoods, and adding the log prior. Here is the implementation.

A from-scratch favorite that tests 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 from-scratch test of the EM algorithm and soft clustering. The signal is the two alternating steps (responsibilities then weighted re-estimation), log-sum-exp for stability, and knowing how GMM generalizes k-means. Here is the implementation.

A from-scratch test of the least-squares closed form and the numerical traps in it. The signal is deriving the normal equations, knowing why you never explicitly invert, and reaching for lstsq or the SVD instead. Here is the implementation.

A from-scratch test of recurrent forward passes and backprop through time. The signal is the shared-weight recurrence, accumulating gradients across timesteps, and explaining the vanishing-gradient problem. Here is the implementation.

A from-scratch test of gated recurrence. The signal is wiring the forget/input/output gates and candidate correctly, separating cell state from hidden state, and explaining why the additive cell path fixes vanishing gradients. Here is the implementation.

A from-scratch test of modern optimizers. The signal is the moment estimates, bias correction, and the one change that matters: AdamW decouples weight decay from the gradient instead of folding it into the loss. Here is the implementation and why it wins.

A from-scratch test of how learning-rate schedules are actually computed. The signal is correct closed-form formulas, knowing when each schedule shines, and why decaying the rate helps convergence. Here is the implementation of the common ones.

A from-scratch test of how PyTorch actually works under the hood. The signal is building a computation graph during the forward pass, local derivatives per op, and a topological-order backward pass that accumulates gradients. Here is a minimal engine.

A from-scratch test of subword tokenization. The signal is greedy longest-match encoding against a fixed vocabulary, the continuation-prefix convention, and how WordPiece differs from BPE. Here is the implementation.

A from-scratch test of distributed input pipelines. The signal 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. Here is the implementation.

A sudden 22-point AUC jump is a gift and a warning. Junior candidates celebrate; strong ones get suspicious and know exactly which leakage checks to run before anything ships.

The most common ML fundamentals question, and a quiet seniority test: anyone recites the definition, but can you decompose the error and turn it into a concrete debugging plan?

The interviewer is testing whether you pick metrics for the problem or recite definitions. The real signal is knowing when accuracy and even AUC lie, and tying each metric to a decision.

Shipping a model is an experiment, and this question separates people who run A/B tests from people who p-hack them. The signal is pre-registering the metric, sizing the test, and resisting the urge to peek.

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

A staple stats question that doubles as a numeracy check. The signal is connecting MLE/MAP to regularization and nailing the base-rate calculation that surprises most people. Here is the intuition plus the worked numbers.

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

Tabular ML is won on features, and this question checks whether you handle the practical traps: target leakage in encodings, missingness that is informative, 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 match approach to data availability and have 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 real 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 say 'L1 is lasso, L2 is ridge'; the signal is the gradient-and-geometry reason L1 drives weights to exactly zero and when you'd pick each. Here is that answer.

Ensembles dominate tabular ML, and this question checks whether you know 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.

SVMs separate the candidates who memorized 'maximize the margin' from the ones who can explain why a kernel gives you non-linear separation without ever touching the high-dimensional space. Here is the answer that lands the second signal.

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

Dimensionality questions test linear-algebra intuition and practical judgment at once. The signal is what PCA actually does (project onto max-variance directions), why high dimensions hurt, and the honest catch: it is unsupervised, so it can throw away the exact direction your label needs. Here is the answer.

EM is the canonical latent-variable algorithm, and a GMM is how it shows up in practice. The signal is the E-step/M-step alternation, why it is soft clustering where k-means is hard, and the honest caveat that it only finds a local optimum. 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.' The signal 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. The signal 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 ties together why deep nets were hard to train and the cluster of tricks that fixed it. The signal is the multiplicative-gradient cause and naming the real fixes: ReLU, He/Xavier init, residuals, normalization. Here is the answer.

CNNs are foundational even as transformers rise, and this checks whether you understand why convolution suits images. The signal 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. The signal 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. The signal 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 past the randomized A/B test. The signal 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 emit meaningless probabilities. The signal is knowing exactly 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 understanding 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 real difference between contrastive and masked-prediction objectives.

Multimodal is now table stakes, and this checks 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.

Voice is a major modality and a common applied-AI surface. The signal is the audio-to-text pipeline, why Whisper is resilient, and the cumulative latency budget that makes or breaks a real-time voice agent.

Sequence models are foundational and still asked, especially the gating that fixed RNNs and why attention won. The signal is connecting the vanishing-gradient story to the parallelism argument that let transformers ride the scaling wave.

GANs defined generative modeling for years, and interviewers want the minimax game, the failure modes (mode collapse, instability), and the precise reason diffusion displaced them for images while GANs still win on speed.

Autoencoders and VAEs underpin representation learning and generative modeling, including the VAE inside latent diffusion. The signal is the gap between a plain autoencoder and a variational one, and why you cannot backprop through sampling without the reparameterization trick.

Transfer learning is why you rarely train from scratch, and the real question is how much of the pretrained model to reuse versus adapt. The signal is a crisp decision grid over data size and task similarity, plus knowing when a low LR saves you from catastrophic forgetting.

Two simple classifiers that still appear in interviews because they test whether you understand assumptions and tradeoffs, not just sklearn calls. The signal is k-NN's laziness and curse of dimensionality versus Naive Bayes' independence assumption. Here is the answer.

Distribution questions test whether you can match a data-generating process to the right model. The signal is knowing what each distribution describes and a concrete use case, not memorizing PDFs. Here is the practical map.

Hypothesis testing underlies every experiment, and the signal is interpreting the p-value correctly (it trips most people) and picking the right test. Here is the rigorous, plain-language answer.

Labels are the expensive bottleneck in ML, and these two techniques attack it from different angles. The signal is knowing active learning chooses what to label while semi-supervised uses unlabeled data directly. Here is the answer.

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

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

Bandits optimize while they learn, shifting traffic toward winners mid-experiment instead of fixing it like an A/B test. The signal is the explore-exploit tradeoff, the three core algorithms, and knowing exactly when a bandit beats a clean A/B test.

Outlier detection shows up in data cleaning, fraud, and monitoring, and there is no single right method. The signal is matching statistical, distance, or model-based families to the dimensionality, distribution, and labels you actually have.

One model, several objectives, one shared backbone. The signal is knowing exactly why sharing helps (regularization, data efficiency) and the failure mode that sinks naive setups. Here is the answer.

The learning rate is the one hyperparameter that can NaN your run on step 50 or stall it forever. Modern training schedules it instead of fixing it. The signal is knowing exactly what warmup and decay each buy you. Here is the answer.

Ranking is not classification, so accuracy is the wrong tool. The signal 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 checks whether you know why ReLU dethroned sigmoid and how to match the output activation to the loss. The signal is the vanishing-gradient story told correctly. Here is the answer.

Everyone says 'gradient descent,' but the batch-size choice and momentum are the real interview content. The signal is the noise-vs-cost tradeoff across batch/SGD/mini-batch and why momentum earns its keep.

The loss defines what the model optimizes, and picking the wrong one quietly dooms it. The signal is matching the loss to the task and data (outliers, imbalance), not defaulting to MSE or cross-entropy on reflex.

Regression needs different metrics than classification, and each tells a different story. The signal is knowing what RMSE vs MAE vs R² vs MAPE actually measure and their failure modes around outliers, scale, and zeros.

Cross-validation gives a reliable performance estimate, but the wrong scheme leaks data and lies. The signal is matching the CV scheme to the data (stratified, grouped, time-series) and fitting preprocessing inside the fold.

These three get conflated, but they answer different questions: one is a preprocessing tool, two are eyeballing tools. The candidates who pass know exactly which structure each preserves and which it quietly throws away.

k-means is the reflex answer, but it quietly assumes round, equal-size clusters and demands you know k upfront. The signal is positioning each alternative by the exact assumption it removes, and knowing when to reach for it.

LDA is the supervised cousin of PCA, and the contrast is a favorite. The signal is knowing that LDA spends the labels to maximize class separation while PCA only chases variance, plus the C minus 1 dimension cap that catches most candidates off guard.

These four quantities underlie cross-entropy loss, decision-tree splits, distillation, and the KL penalty in RLHF. The signal is deriving them from one another and pointing to exactly where each shows up in a real training loop.

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

HMMs are the classic probabilistic sequence model behind speech and tagging, and Viterbi is how you decode them. The signal is the hidden-states plus transitions/emissions structure, and that Viterbi is dynamic programming for the single best state path, not a probability.

Bad initialization makes deep nets fail to train at all, with activations that vanish or explode through depth. The signal 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. The signal is naming the concrete effects (distances concentrate, data goes sparse, overfitting climbs) and the mitigations that actually move the needle.

Feature selection cuts noise, overfitting, and serving cost, but the three method families pull in different directions. The signal 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.' The signal 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. The signal 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. The signal 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 the signal 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 generates labels programmatically instead, and the signal 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 the signal 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.

Gaussian Processes give predictions with principled uncertainty, which is why they power Bayesian optimization. The signal is the distribution-over-functions intuition, the kernel's role, and naming the O(n cubed) wall. Here is the answer.

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

RL underpins RLHF, robotics, and recommendation, and interviewers want the core framing. The signal 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. The signal is the label-preserving constraint and why text is the hard one. Here is the answer.

Two cheap regularizers that fix overconfident classifiers. The signal is knowing that one softens the target and the other softens the input, and exactly why softer signals calibrate the model. Here is the answer.

Ranking is not regression: getting the absolute score wrong is fine, getting the order wrong is not. The signal is the pointwise/pairwise/listwise split and why pairwise (LambdaMART) is still the practical default. Here is the answer.

Classic bias-variance says bigger models eventually overfit, yet deep nets keep improving past the point where they memorize the data. The signal is explaining the second descent and why over-parameterized models generalize. Here is the answer.

Wrap any model and get prediction sets with a provable coverage rate, no distributional assumptions required. The signal is the calibration-set plus nonconformity-score mechanism and exactly what the guarantee does and does not promise. Here is the answer.

Time-to-event problems (churn, failure, conversion timing) hide a twist that quietly biases plain regression. The signal is naming that twist and reaching for the right framing. Here is the answer.

Many real problems give you confirmed positives but never confirmed negatives, only unlabeled data. The shortcut everyone reaches for quietly biases the model. The signal is naming the regime and its fix. Here is the answer.

Some models are natively multiclass; others need a wrapper to stretch a binary classifier to K classes. The signal is knowing the three strategies and exactly when each one wins. Here is the answer.

A model can rank perfectly and still lie about its probabilities; its 0.9 may be right 70% of the time. The signal is knowing the three fixes, which data size each needs, 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 hinges on your model and what you need from it. This is the answer that separates rote from understanding.

Everyone can recite 'linearity and normality.' Few can say which assumption matters for predictions versus inference, how to spot 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 whole experiment is suspect. Strong candidates name sample-ratio mismatch on sight. Here is the full diagnosis and the disciplined response.

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

'The model won't train' has 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.

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

Defaulting to 0.5 is leaving 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 make decisions on that bar chart. Here is why default importance lies and what a careful answer reports instead.

Small labeled sets are the normal starting condition, not an excuse. The strong answer is a ladder of techniques that squeeze signal from unlabeled data, pretrained models, and the labeling budget. Here it is.

Most real datasets have wrong labels, and they cap your accuracy invisibly. Cleaning all of it by hand doesn't scale. Here is how to find the bad labels and train robustly around them.

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

Generative training fails in distinctive ways: GANs collapse to a few outputs, diffusion samples come out noisy or blurry. The symptom tells you which knob to turn. Here is the diagnosis.

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

For search and recommendation, A/B tests can be slow and noisy because they compare different users. Interleaving compares two rankers within the same user's results and detects winners with far less traffic. Here is how.

Boxes and labels, not one tag per image. The signal is choosing two-stage vs one-stage by your latency and accuracy budget, knowing what NMS and anchors actually do, and reporting mAP correctly. Here is the answer interviewers score highest.

Most CV systems fail at the seams: a preprocessing mismatch between training and serving, not the model. The signal is naming every stage from ingestion to serving and the one consistency invariant that breaks teams. Here is the answer.

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

Semantic labels every pixel by class; instance separates each object. The signal is knowing that one 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 mean deep learning. The signal is reasoning from dimensionality, data type, inference latency, and label budget, then noting where KNN quietly survives as approximate nearest neighbor. Here is the answer.

Most candidates can recite 'maximize the margin'. The dual is where you show you actually understand why only support vectors matter and where the kernel trick comes from. Here is the derivation an interviewer wants.

EM on a Gaussian mixture has a famous failure mode: a Gaussian collapses onto one point and likelihood shoots to infinity. Knowing why, and the three standard fixes, separates people who used sklearn from people who understand it.

Both tag sequences, but one is generative and one is discriminative, and that difference decides whether you can throw in overlapping features. Here is the comparison that shows you know the modeling tradeoff, not just the acronyms.

Anyone can say 'ensemble of trees'. The real answer is about decorrelating those trees and why that, not just averaging, is what drops variance. Here is what makes the forest more than the sum of its trees.

XGBoost made boosting practical; LightGBM made it fast. The answer is histogram binning, gradient-based sampling, and leaf-wise growth, each with a real tradeoff. Here is what they do and where they bite.

Bayesian inference needs an intractable normalizing constant, and MCMC sidesteps it. The signal is explaining the acceptance ratio, detailed balance, and why you can skip the constant entirely. Here is the answer.

The 'naive' independence assumption is wrong on real data, yet the classifier is a strong baseline for text. The interesting answer explains why classification survives a broken assumption, plus smoothing and the variants. Here it is.

k-NN looks trivial until you ask about choosing k, why distances stop meaning anything in high dimensions, and how to make prediction fast on millions of points. Here is the tradeoff-aware answer.

k-means assumes round, equal-size blobs and a known k. DBSCAN finds arbitrary shapes and outliers but has its own knobs. The hard part is judging clusters without labels. Here is the comparison and the evaluation toolkit.

Univariate ranking is the trap everyone falls into: it keeps redundant features and drops ones that only matter in combination. Here is the filter/wrapper/embedded breakdown plus mRMR and Boruta, and where each one bites.

Lasso gives sparsity, Ridge handles correlated features, and each fails where the other shines. Elastic Net blends them for a specific, common failure. Here is when it earns its two hyperparameters.

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

The Kalman filter is optimal Bayesian tracking under linear-Gaussian assumptions, and it is two steps repeated forever. The signal is explaining what the gain trades off and when the assumptions break. Here is the answer.

There is no single fairness number, and a famous result proves you cannot satisfy the main three together. The signal is defining each metric precisely and explaining the impossibility, not picking one blindly. Here is the answer.

Both explain a single prediction by attributing it to features, but only one rests on a uniqueness theorem. The signal is knowing SHAP's game-theory guarantees, LIME's instability, and when each is the right tool. Here is the answer.

Raw gradient saliency maps are noisy and saturate. Integrated gradients fixes both with two axioms and a path integral, but the baseline choice quietly decides the answer. Here is what a careful candidate explains.

Sessionization separates people who reach for a self-join from people who know LAG plus a running sum. Here is the two-pass pattern that scales to billions of events, plus the edge cases interviewers push on.

Pipelines fail and retry; the real question is whether a retry corrupts your data. The signal is idempotent writes (not 'exactly-once delivery') plus watermarks for late data. Here is how to make re-runs safe without double-counting.

A hard streaming-systems question: dedup at high throughput with bounded state. The signal is a tiered state design (probabilistic filter in front of durable state) plus watermark-driven eviction. Here is the architecture that does not OOM.

A pipeline-design question that rewards matching the architecture to the freshness requirement, not chasing real-time for its own sake. The signal is the latency-vs-complexity tradeoff and knowing why Kappa emerged to kill Lambda's dual codebase. Here is the decision.

The difference between a query that scans a terabyte and one that scans a gigabyte is usually layout, not the engine. The signal is partition pruning, columnar formats, and the small-files problem.

Syncing a warehouse with a live OLTP database is a CDC problem, and the naive 'full reload nightly' or 'query by updated_at' answers have real holes. The signal is log-based CDC and idempotent merges.

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

A new column is safe; a rename silently corrupts every dashboard downstream. The signal is knowing which changes are 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 clear story for late and out-of-order events.

The top cause of mysteriously slow Spark jobs: one partition does 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.

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

Modern warehouses store JSON natively, and querying it well separates strong data engineers from the rest. The signal is path access plus unnesting, and a clear call on when to flatten hot fields versus keep the schema-on-read flexibility.

You cannot filter on a window function in WHERE, so people wrap queries in subqueries. QUALIFY filters window results directly. The signal is knowing why WHERE cannot do it and writing top-N-per-group cleanly.

Modern table formats let you query a table as of a past version or timestamp, the backbone of reproducibility, audits, and recovery. The signal is the versioned-snapshot mechanism and where it breaks.

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

Two queries that look identical except for ROWS vs RANGE return different numbers, and most candidates cannot say why. The signal is knowing RANGE groups by value (peers) while ROWS counts physical rows.

Partition on the wrong key and you get millions of tiny files or skewed giants. The signal is partitioning on a low-cardinality filter, clustering within partitions on the next predicate, and watching file size.

At-least-once duplicates and at-most-once loses data; everyone wants exactly-once and few can explain how Kafka delivers it. The signal is idempotent producers plus transactional read-process-write plus the read-committed isolation that ties them together.

When a metric looks wrong, lineage tells you which upstream table to blame. The signal is distinguishing table vs column lineage and knowing the three ways to capture it: SQL parsing, runtime hooks, and metadata APIs.

Events show up minutes or days after they happened, and a window that already closed gives wrong counts. The signal is event-time vs processing-time, watermarks with allowed lateness, and how you correct already-emitted aggregates.

A flat path extract is easy; an array of objects three levels deep is where people freeze. The signal is LATERAL FLATTEN / UNNEST to explode arrays into rows and a clear rule for when to flatten vs query in place.

Most candidates only know 'use Debezium.' The signal is comparing three CDC mechanisms by how they capture deletes, load the source, and handle ordering, plus the snapshot-to-stream stitching that trips up real deployments.

This is two questions hiding as one: how would you have caught it before full rollout, and how do you debug it now. Answer both and you signal senior judgment. Here is the staged-rollout and root-cause playbook.

The modal ML system design round. The structure interviewers reward is the funnel: candidate generation then ranking then re-ranking, with the right model at each stage and an honest plan for cold start, freshness, and feedback loops. Here is that structure.

Extreme class imbalance plus a hard latency budget plus an adversary who adapts. The signal is handling imbalance honestly, choosing the operating point from costs, and designing for the feedback loop. Here is the end-to-end design.

Multimodal search tests whether you understand shared embedding spaces and the retrieve-then-rank pattern under a real catalog's scale and freshness. The signal is CLIP-style joint embeddings plus hybrid retrieval and honest relevance evaluation. Here is the design.

Text-to-SQL is deceptively hard because correctness is binary and the failure mode is a confident wrong number. The signal is schema grounding, query validation, and a safety layer, not just 'prompt an LLM with the schema.' Here is the production design.

Moderation is a multi-stage classification problem with brutal tradeoffs: false negatives cause real harm, false positives censor legitimate users, and the adversary adapts. The signal is the tiered pipeline, per-severity precision/recall calibration, and human-in-the-loop. Here is the design.

Ads ranking is where calibrated probabilities meet hard latency and money. The signal is knowing that CTR must be calibrated (not just ranked), the feature and serving design, and the auction context. Here is the design that goes beyond 'train a classifier.'

Anomaly detection sounds easy until seasonality, cold start, and alert fatigue hit. The signal is modeling the expected baseline (including weekly and daily cycles), choosing unsupervised methods for scarce labels, and tuning to avoid drowning users in false alarms. Here is the design.

The canonical AI system-design question. The signal is covering both the model lifecycle and the serving stack under real scale, without rambling. Most candidates design only half and lose the points.

The modern agentic system-design question. The signal is the plan, search, read, synthesize, verify loop with per-claim citations, plus bounding cost and latency. The hard parts are not the writing.

Cross-session memory is what makes an assistant feel personal, and it is mostly a retrieval and state-management problem, not a bigger context window. The signal is the tiered architecture plus what to store, forget, and protect.

AI code review lives or dies on precision: a few noisy comments and the team mutes the bot forever. The signal is grounding in the diff plus repo context, ruthless false-positive control, and earning developer trust one accepted comment at a time.

Summarize, draft, triage, all over the most sensitive PII a person owns. The signal is grounding in the actual thread, matching the user's voice, and a hard human-in-the-loop rule on anything that gets sent.

A GPU-heavy generative system where sampling steps dominate the bill and one bad image is a headline. The signal is the diffusion serving pipeline, the cost levers on per-image GPU time, and a mandatory two-sided safety layer.

Resume screening is high-scale and high-stakes: a legally sensitive, bias-prone decision about people. The signal is balancing throughput with fairness, human oversight, and explainability, not an LLM ranking resumes. Here is the design.

Real-time transcription at scale tests streaming ASR, latency budgets, and GPU fleet management under heavy concurrency. The signal is streaming chunked inference with partial results, not batch transcription. Here is the design.

Document extraction (IDP) is a huge enterprise use case with a hard correctness bar: a wrong extracted number is worse than none. The signal is the parse, extract, validate, human-review pipeline and confidence-based routing. Here is the design.

A voice assistant chains STT, an LLM, and TTS under a brutal latency budget where every stage adds delay. The signal is streaming and pipelining the stages plus turn-taking, not three blocking calls. Here is the design.

Healthcare is the highest-stakes AI domain: a wrong answer can harm a patient, and regulators are watching. The signal is designing decision support with grounding, human oversight, and guardrails, never an autonomous diagnoser. Here is the design.

Legal review is high-stakes and precision-critical: a missed clause or hallucinated citation has real consequences, and lawyers have been sanctioned for fabricated cites. The signal is grounding in the actual documents, citing exact passages, and lawyer-in-the-loop. Here is the design.

Dynamic pricing blends demand forecasting, optimization, and real-time serving, with 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 collide, and it carries a hard 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 makes it shippable.

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

Code migration is a high-value agentic task with an unforgiving correctness bar: the migrated code must still work. The signal is grounding in the real repo, transforming in verifiable chunks, and gating on tests, never one giant LLM rewrite.

Notification systems fail by spamming users into muting them, 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.

Two models chained (ASR then summarization), a long-context problem hiding inside, and a faithfulness bar where a fabricated action item has real consequences. The signal is the pipeline plus how you keep a 3-hour transcript honest at thousands a day.

On-device AI trades raw capability for privacy, offline use, and latency, under brutal memory and battery limits. The signal is the small-quantized-model stack plus a hybrid router that escalates the hard queries to the cloud without leaking private context.

The trap is replacing the classifier with an LLM. The real-time, imbalance, and adversarial constraints do not go away. The signal is a hybrid: a fast calibrated model scores inline, LLMs investigate the gray zone off the hot path.

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

Every keystroke needs ranked suggestions back 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 survives the latency budget.

ETA is spatiotemporal regression served in real time over conditions that change by the minute. The signal is feature freshness, segment or stage decomposition, and the asymmetric cost of being wrong. Here is the design.

PYMK is graph recommendation at billion-node scale. The interviewer is screening for one instinct: do you generate candidates from the social graph, or naively try to score all pairs? Here is the design that survives the follow-ups.

The service behind every RAG stack and semantic search box. The signal is your ANN index choice and how you handle the three things that quietly break it: metadata filtering, live updates, and scale.

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

Image search is embedding retrieval at billion-image scale. The tell of a strong answer is knowing when a vision-only encoder suffices 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 for whether you set the threshold by cost asymmetry and lean on signals spammers cannot fake. Here is the design.

Query understanding is the front end of search that turns 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.

Some questions need precise multi-hop facts that vector retrieval can't chain. The signal is entity linking plus query translation over a graph (or GraphRAG), and knowing when the graph is worth its maintenance cost. Here is the design.

Translation is seq2seq generation served across hundreds of language pairs under tight latency and quality budgets. The signal is dodging the quadratic pair explosion, rescuing low-resource languages, and serving it cheaply. Here is the design.

Recognizing walking, driving, or a fall from a sensor stream is windowed time-series classification, usually on a battery-bound device. The signal is windowing, temporal smoothing, and the on-device constraints most candidates skip. Here is the design.

Recommending events (or jobs) breaks normal recsys in two places: items expire and items are local. The signal 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 easy version fails three ways: it is multi-label, the taxonomy is hierarchical and keeps growing, and rare classes hide behind aggregate accuracy. The signal is the model choice plus how you handle all three.

Labeled data is the fuel for ML, and a labeling platform lives or dies 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 comes down to one driving tradeoff plus a handful of CV specifics most candidates fumble: the detector family, NMS, focal loss, and why mAP not accuracy is the metric. Here is the design.

Two forces decide this design: documents longer than the context window, and summaries that must not lie. The strong answer pairs hierarchical map-reduce with claim-level grounding, then serves it cheaply at scale.

Batch scoring a billion items is a throughput-and-cost problem, the opposite of low-latency serving. Every choice that hurts latency helps you here. Here is how to design for dollars-per-million-documents.

An agent that clicks around a real website is slow, brittle, and one wrong click from a costly mistake. The architecture is about perception, action, and guardrails around irreversible steps. Here is how to build it.

'What was revenue by region last quarter?' sounds like text-to-SQL, but production analytics agents fail on ambiguity, wrong joins, and confidently wrong numbers. Here is the architecture that makes the answers trustworthy.

Anthropic's signature opener. The naive answer (one server pushes to N clients) is bottlenecked 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 land on the CAP spectrum. Here is how to reason about all three with concrete quorum math.

Every API platform needs one. Interviewers reward the candidate who picks the right algorithm (token bucket vs sliding window) for the burst behavior, then solves the genuinely hard part: enforcing one shared limit across many servers without a per-request round trip to a central store.

Looks simple until the follow-ups: which layer do you balance at, how do you avoid sending traffic to a dead server, and how is the load balancer itself not 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 decisions are how you generate short, collision-free, unguessable keys at scale, and how a read-heavy 100:1 workload shapes the storage and caching. Here is the clean design with capacity math.

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

The distributed ordering question, the conceptual core of Kafka, replicated logs, and consensus systems. Interviewers want to see you confront the hard truth that physical clocks lie, then reach for the actual tools: a single sequencer, consensus, or logical clocks. Here is that progression.

The real-time messaging classic. Interviewers want the delivery path (persistent connections, not polling), the fan-out strategy that does not collapse on large groups, and an ordering and delivery-guarantee story. Here is that design with the fan-out tradeoff that separates seniors.

This is the question to design the scoreboard, not the player. A strong answer separates offline gates (AUC, calibration, NDCG) from the online verdict (A/B with revenue, user, and advertiser guardrails), and adds counterfactual replay so you can trust a model before it ever serves a real auction.

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

Truth is not a label you can train on cheaply, and adversaries adapt the moment you ship. A strong answer fuses content, graph, and behavioral signals, puts humans in the loop where precision matters, and treats adversarial drift as a permanent operating condition, not a one-time training problem.

Detecting the language of a string sounds trivial until the input is three words, mixes two languages, or is half code. A strong answer picks the model by latency budget, handles short text and code-switching, and returns calibrated confidence instead of a brittle single guess.

Cleaning noise out of speech is a tradeoff between how good it sounds and how fast it runs. A strong answer picks spectrogram masking versus waveform models against a real-time budget, names PESQ and STOI as the metrics, and is honest about the artifacts each approach introduces.

Video search is image search with 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) finds the right moment, not just the right video.

Enterprise search lives or dies on permissions, freshness, and connecting to thirty messy SaaS sources; retrieval quality is table stakes. Learn how to fan out across connectors, enforce per-user access at query time, and blend lexical with vector search for results people trust.

Summarizing a 200-page contract is not one LLM call: it is chunking, hierarchical reduction, and a faithfulness check so you never invent facts. Learn the map-reduce pattern, when long-context beats it, and how to evaluate summaries at scale.

Moderating billions of items a day with an LLM on every 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 keep up with 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, manage long-term memory without bloating the prompt, and respect privacy and the right to be forgotten.

A writing assistant has to feel instant while a cursor moves through a live document. Learn how to split fast deterministic checks from LLM rewrites, stream suggestions, and keep edits stable so the text does not flicker as the user types.

Experimenting on LLM features is hard because the outputs are open-ended and quality is fuzzy. Learn how to assign traffic, pick metrics that are not just engagement, handle variance from non-determinism, and avoid the traps that make a winning variant lose in production.

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

A rider taps request and within seconds a nearby driver is assigned. The interesting problems are geospatial indexing of moving drivers, the matching objective (nearest is not always best), and handling the race where two riders want the same car. Here is how to build it.

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

Find the 20 nearest restaurants within 5km, fast, for millions of users. A naive distance scan over every place is hopeless. The design is about spatial indexing, geohash or quadtree partitioning, and handling dense cities versus empty regions. Here is how proximity search works.

When a page loads, an ad slot is auctioned to dozens of bidders and a winner is chosen 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.

The naive answer is 'retrain weekly.' The senior answer is a hybrid: drift-triggered retraining with a max-staleness fallback, plus a gate that a fresh model must beat the incumbent. Here is how to reason about it.

A feature store is easy to define and easy to get wrong. The signal is explaining the exact bug it prevents (training-serving skew) and the point-in-time correctness that stops label leakage. Here is the full picture.

The trap is describing plain software CI/CD. The signal is the three things ML adds: data validation, a model-quality gate against a baseline, and versioning data plus model plus code together. Here is what is genuinely different.

At thousand-GPU scale, hardware failure is the norm, not the exception, and a run that cannot resume wastes weeks. The signal is checkpointing strategy, deterministic resume, and minimizing lost work. Here is the fault-tolerant design.

Reproducibility is what separates an ML platform from a pile of notebooks. The signal is tracking the full provenance (data, code, config, metrics) and a registry that governs promotion. Here is what to track and why each piece matters.

Deploying a model is not flipping a switch. The signal is knowing what each rollout strategy validates, why shadow is uniquely useful for ML, and keeping rollback one step away. Here is the comparison and when to use each.

Grid search is the wrong answer at scale. The signal is knowing why random beats grid, how Bayesian optimization and early-stopping schemes (Hyperband/ASHA) spend compute smartly, and how to parallelize without stragglers.

GPU spend is usually the biggest line item in an AI org, and this question checks whether you think in utilization, not just capacity. The signal is squeezing per-unit cost (utilization, right-sizing, spot, quantization) before scaling out.

The most common ML production failure is not a code bug, it is a quiet upstream data change. The signal is validating at ingestion (schema plus distribution), data contracts with producers, and failing loud instead of training on garbage.

LLMOps is not MLOps with bigger models. The signal is the genuinely new surfaces (prompts as deployable artifacts, eval-driven development, often no training step) and treating prompts with the same version discipline as code.

Models decay silently as the world shifts, and 'monitor for drift' is too vague. The signal is the actual statistical methods and distinguishing data drift you can detect without labels from concept drift you often cannot.

A high accuracy number hides slice failures, brittleness, and silent data bugs. The signal is naming the test layers that catch what the headline metric can't. Here is the framework that gets scored highest.

When a model regresses or an auditor asks 'how was this built,' guesswork is a failing answer. The signal is tracking the whole chain so any model is reproducible and any past decision is explainable. Here is the chain.

Not every prediction needs a low-latency endpoint, and defaulting to one burns money. The signal is matching the serving pattern to the latency and freshness requirement. Here is the decision and when you'd reverse it.

Models are only as good as their labels, and noisy annotation silently caps performance. The signal interviewers want is a measured quality process, not a louder collection effort. Here is the answer.

A bad model in production needs a fast, safe rollback, but ML rollback is trickier than code: the model is data and the truth signal lags. The signal is pre-defined criteria plus a previous version kept warm. Here is the answer.

Shadow deployment validates a new model on real traffic without exposing users to it. The signal is knowing outputs are served in parallel then discarded, and how it complements canary and A/B. Here is the answer.

ML workflows are multi-step DAGs (ingest, feature, train, eval, deploy), and orchestrators run them reliably. The signal is the DAG/scheduling model plus what's actually ML-specific: data deps, versioned artifacts, drift triggers, eval gates.

Monitoring an ML system is more than CPU and latency; the model can silently rot while the dashboard stays green. The signal is the four-layer taxonomy (operational, data, prediction, outcome) and using inputs as leading indicators because labels lag.

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

'Why was I denied?' is a question regulators and customers will ask, and 'we retrained since then' is not an acceptable answer. Exact reproduction means versioning everything. Here is what 'everything' actually means.

Automating retraining sounds like a convenience until an auto-retrained model silently ships worse. The gates are the whole point. Here is how to automate retraining without automating a regression into production.

An alert that fires constantly gets muted, and a model that fails with no alert is worse. Good ML alerting is a design problem with the same principles as SRE, plus ML-specific twists. Here is how to get it right.

Every team reinvents 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, links them by lineage, and makes thousands of experiments comparable, which is a different system from a model registry.

A green build still means nothing for model quality. The signal is an eval harness that runs deterministically in CI, compares against a frozen baseline, and blocks the merge on regressions. Here is how to make it fast, stable, and trusted.

'Just set a seed' is the wrong answer. Reproducibility means pinning the environment, the data, the code, and the hardware-level nondeterminism, all at once. Here is the full checklist and where it leaks.

Saying 'route 5% to the canary' is the easy part. The signal is how you split traffic deterministically, gather enough signal to decide, and ramp on evidence rather than vibes. Here is the mechanics layer.

Three drifts get casually lumped together, but they have different detectability and different fixes. The interview signal 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, if you know which output signals actually move first.

Classic SRE SLOs assume a request is right or wrong. ML predictions are probabilistic and labels lag, so naive uptime SLOs miss the failures that matter. Here is how to set SLOs that actually cover model quality.

ML incidents are slipperier 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.

The interviewer wants you to know why a model that fits on no single GPU still trains, and to do the optimizer-state memory math that motivates sharding. Here is the parallelism taxonomy and the 16-bytes-per-parameter calculation.

A favorite at hardware-aware shops. The signal is understanding that attention's cost is memory traffic, not FLOPs, and that FlashAttention is an exact, IO-aware reordering, not an approximation. Here is the answer that shows you think about the memory hierarchy.

The KV cache is why LLM serving is hard, and the interviewer wants the mechanics: what it stores, why it limits concurrency, and the tricks that shrink it. Here is the answer that shows you understand decode-time economics.

Mixed precision is standard at scale, and the interviewer wants the numerics: why FP16 needs loss scaling, why BF16 mostly does not, and what stays in FP32. The signal is understanding dynamic range vs precision. Here is that answer.

A hardware-literacy question, especially at NVIDIA and the labs. The signal is understanding throughput vs latency hardware, the memory hierarchy, and why matrix multiplication maps onto GPUs and TPUs. Here is the architecture-aware answer.

Distillation buys you a small fast model that keeps most of a big model's quality. The signal is explaining why soft targets transfer more than hard labels, and knowing when to distill versus quantize versus prune. Here is the model-compression answer.

At NVIDIA and the labs this compute-intimacy question is real. The signal is owning the SIMT execution model and the three classic throughput killers, with the concrete fix for each. Here is the low-level answer.

On-device AI is a real product surface (privacy, offline, latency), and it forces hard constraints. The signal is the quantization plus format plus runtime stack and the tradeoffs you accept under tight memory and battery budgets.

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

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

When a model is too big for one GPU you split the model itself, not just the data. The signal is distinguishing tensor parallelism (split within a layer) from pipeline parallelism (split across layers) and matching each to the interconnect. Here is the answer.

A PyTorch model in eager mode is not the fastest form for inference. The signal is knowing that ONNX buys portability and TensorRT-style compilers buy hardware-tuned speed, and exactly which optimizations get you there. Here is the answer.

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

nvidia-smi showing 100% can hide that you are using a fraction of the hardware's real compute. The signal is MFU (useful FLOPs vs peak) and the gap between 'the GPU is busy' and 'the GPU is efficient'.

Beyond FP16/BF16, FP8 is the next rung on the precision ladder, and the latest tensor cores compute on it natively. The signal is knowing the two formats, what FP8 actually buys, and why dynamic range forces careful scaling.

A freshly started replica is slow on its first requests while it loads weights and compiles kernels, and that clashes with reactive autoscaling. The signal is naming the cold-start sources and the warmup and provisioning fixes.

Pruning removes redundant weights to shrink and sometimes speed up a model. The signal is the structured-versus-unstructured split and why only structured pruning reliably wins latency on commodity hardware.

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

Linear scaling is the marketing number; the real curve bends early for reasons that are physics, not bugs. Here is where the speedup goes and how to claw it back.