Google AI Engineer interview questions

Nearly every candidate can recite softmax(QKᵀ/√d_k)V. What the interviewer is after is the variance derivation and the precise training failure the scale heads off. This is the response that tells rote recall apart from real grasp.

The most frequently asked applied GenAI question, and the one most candidates turn into a definition dump. What the interviewer wants is a decision framework with a default and the conditions that override it. Here is the call that earns points.

A tidy fundamentals question that trips up anyone who only knows GPT. The signal is pairing each architecture to its task through its attention pattern, and explaining why the field settled on decoder-only even for tasks that are not generation. Here is that answer.

Tokenization reads like plumbing until it accounts for your bill, your latency, and why the model stumbles on numbers and rare languages. The signal is understanding how subword tokenizers operate and the consequences that follow from them.

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

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

Every LLM product tunes these knobs, and the interviewer wants to hear what each one does to the probability distribution and which setting suits which task. That includes why factual and creative tasks call for opposite settings.

Evaluation is the toughest and most underrated part of shipping LLMs. The signal is understanding why public benchmarks mislead, why LLM-as-judge carries bias, and how to build a task-specific eval you can genuinely trust.

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

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

In-context learning is the property that turned prompting into a paradigm; chain-of-thought is its most useful trick. What matters 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 purchase accuracy with extra compute. What matters is knowing how each explores the reasoning space, that they trade tokens and latency for reliability, and how to judge when the problem actually warrants it. Here is that answer.

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

The 2025-2026 landscape isn't 'bigger is better' anymore. What matters 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 steering a model around its own safety training. What matters is naming the technique families and treating defense as a layered, never-finished arms race, not a one-time patch.

Instruction tuning converts a bare next-token predictor into a model that obeys instructions. What you are being tested on is slotting it correctly into the pretrain to SFT to alignment pipeline and stating precisely what it does and does not repair.

Fine-tune a model on your domain and it may lose the ability to do everything else. What earns the signal is explaining why shared weights cause it and listing the concrete mitigations that all boil down to one principle.

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

The classic automatic metrics for generated text. Interviewers want you to pair each with its task and identify the blind spot common to all three. Candidates who pass explain why none of them is the last word on quality.

Plenty of people cite benchmark numbers; almost nobody reads them carefully. What shows depth is explaining what each one measures and why leaderboard figures outrun real-world skill. The question the interviewer is saving is how you would spot contamination.

LLM-as-judge is how you grade open-ended generation at scale, and G-Eval put a formal frame on it. What shows depth is naming the biases that make raw judge scores untrustworthy and demonstrating exactly how you harden them.

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

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

Attention gets all the attention, but the feed-forward layers hold most of a transformer's weights and handle much of the per-token 'knowledge' work. What shows depth is knowing what the FFN computes and why it dominates the parameter count.

Context windows are not arbitrary figures; they follow from attention's quadratic cost, KV-cache memory, and how the model was trained. What shows depth is naming all three causes and matching each to the technique that extends it.

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

RLAIF and Constitutional AI trade human preference labels for AI-generated ones to scale alignment. What shows depth is naming exactly what they substitute for human feedback, and the consistency-versus-bias tradeoff that swap introduces.

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

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

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

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

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

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

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

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

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

Fuse 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 pick 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 nearly everyone overlooks: 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 mirror 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 a separate one. The signal is the detection toolkit, why each signal is imperfect, and how you merge 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 shifts the FLOP story. Here is the sharp version.

Hand-tuned prompts break on the next model upgrade and fail to 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 that claims a million-token window may not actually exploit it. The signal is knowing needle-in-a-haystack, where it fails, and how to probe genuine multi-fact reasoning across the entire context. Here is the answer.

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

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

Push any proxy hard enough and the model discovers 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 by itself. If your prompt is fragile to things that shouldn't matter, the fix is structural, not lucky example-hunting. Here is what genuinely reduces variance.

CoT is not a blanket upgrade. On some tasks it does nothing or backfires, and the reason points to 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 relies on 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 declines 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 silently bias training.

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

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

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

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

A reward model converts 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.

By swapping costly human labels for an LLM's preferences, RLAIF scales cheaply but carries over the labeler model's biases. What matters is how AI feedback gets gathered and where it silently breaks down.

MQA and GQA cut the KV cache by sharing key/value heads. MLA goes another way: compress K and V into a low-rank latent and cache that instead. What matters is recognizing it as a cache trick rather than a head-sharing trick, and why it preserves quality.

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

At long context it is the KV cache, not the weights, that saturates the GPU. What matters is naming the levers (quantization, token eviction, head sharing, low-rank) and the quality cost of each.

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

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

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

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

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

Autoregressive models commit one token at a time, left to right. Diffusion language models generate the whole sequence at once and refine it over several denoising steps, which buys parallel decoding and global editing but has not yet caught the frontier. The signal is knowing the tradeoff, not just the buzzword.

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

The instinct is to blame the vision encoder. It is a token-budget problem, and the fix is to retrieve pages before you look at them. What separates a strong answer is knowing which question types page retrieval quietly cannot answer.

An emerging alternative to stuffing the window or building an index: keep the context outside the prompt and let the model write code to inspect it, recursing into the pieces. Knowing when it does not pay is most of the score.

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

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

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

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

The staged recipe is the easy half. The half that sinks real projects is data licensing, an evaluation bar that needs actual domain experts, and knowing which parts of the problem fine-tuning cannot solve at all.

Summarization is the one task where the model was handed everything it needed and still made something up. The signal is separating intrinsic from extrinsic hallucination, knowing why ROUGE cannot see either, and gating on entailment before you ship.

Truncate, map-reduce, refine, retrieve, or stuff a long-context model. Each buys you something different and breaks differently. The candidates who score are the ones who pick based on the question being asked, not the document being read.

A one-word rewrite moving your accuracy several points is not a prompting problem, it is an uncalibrated decision function. The fix is measuring the model's prior over labels and dividing it out, not another round of tinkering.

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

Letting a model write your prompts works, right up until the optimizer memorizes your eval set and hands you an unreadable prompt that scores better and generalizes worse. The bounds are the whole answer.

The most repeated trick in prompt engineering, and the evidence for it is much thinner than the folklore. A screening question for whether you measure your prompts or inherit them from a thread of screenshots.

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

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

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

Most candidates answer 'use the reasoning model for hard problems' and stop. The interviewer wants it framed as an eval and a budget problem: how you prove the extra thinking tokens paid off, and what you do when the model talks itself out of a correct answer.

A 2025-2026 question that trips up 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 deciding.

Code-execution agents are powerful and risky: arbitrary model-generated code runs on your infrastructure. The signal is genuine 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 only text, and text-only RAG quietly drops them. The signal is knowing the two retrieval approaches and why the generator has to change too. Here is the answer.

A computer-use agent operates a real browser or desktop via screenshots and clicks. The signal is the perceive-decide-act loop together with 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: pull a broad set, then reorder it 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 breaks on questions that chain facts ('who directed the highest-grossing film of 2019?'). The signal is decomposing or iterating retrieval rather than retrieving once, and guarding against errors compounding across hops. Here is the answer.

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

A short question and the passage that answers it sit in different neighborhoods of embedding space. HyDE bridges that gap by embedding a fake answer rather than the question. The signal is understanding why a wrong hypothetical still retrieves the right docs.

Standard RAG trusts whatever it retrieves, even when it's irrelevant. Corrective RAG scores 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 keeps one vector per token, so a corpus that fit in a few GB as single vectors can swell 100x. Interviewers want to see you know the compression and indexing tricks (centroids, residuals, PLAID) that make multi-vector retrieval shippable.

A single embedding cannot capture a question with three independent parts. Interviewers want to see you know 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. Interviewers want to see you retrieve the right schema, generate validated SQL, and know when to query the database instead of embedding it.

Splitting source files every 500 characters slices functions in half and wrecks retrieval. Interviewers want to see you chunk on syntax, retrieve by symbol and dependency, and blend lexical exact-match with semantic search the way code search actually needs.

Linear agents lock into 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 a single good agent.

Final-answer accuracy conceals 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 grasping 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 operates, when self-critique genuinely helps versus when it is theater, and what makes it real.

Any content an agent reads can smuggle in 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.

Screen-driving and browser agents break in ways chat agents never hit: stale DOM, pages that keep shifting, misplaced clicks. What interviewers watch for is the grounding and reliability methods that move a flaky demo toward something dependable.

The agent loop assumes an observation is a short string, and images break that assumption in both directions. The signal is a context policy that keeps pixels out of the transcript and a verification step for the files the agent produces.

The runaway loop gets all the attention. The failure that actually ships is the agent that declares victory on step 4 with half the work missing. The signal is a finish tool the harness can reject, and a completion check that reads the artifact instead of taking the model's word for it.

Agent PR volume scales with compute; human review capacity does not. Most candidates answer 'add an AI reviewer' and miss the real design problem: deciding which changes deserve human judgment at all. Interviewers want a risk-tiered pipeline you would trust in production.

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

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

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

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

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

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

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

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

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

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

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

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

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

BPE powers GPT-style tokenizers, and coding it shows you grasp how subword vocabularies get constructed rather than just knowing they exist. What interviewers watch for is the repeated merge of the most common adjacent pair.

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

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

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

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

Coding the KV cache shows you understand why decode is efficient: you append the new token's K/V and reuse the rest rather than recomputing. Interviewers look for the append-and-attend-over-cache logic. The implementation follows.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Single-head attention shows up often; multi-head layers on the split-into-heads, attend-per-head, concatenate pattern. What gets scored is the reshape into heads plus a sharp explanation of why several heads help. Here is the implementation.

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

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

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

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

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

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

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

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

Comparing all pairs across a million documents is a trillion comparisons. MinHash estimates Jaccard similarity from a tiny signature, and LSH converts dedup into a near-linear scan. Here is the implementation.

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

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

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

Ahead of transformers, this was the language model, and it remains the clearest way to prove you grasp what perplexity truly measures. Smoothing is where people slip up. Here is the implementation.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The classic multi-round build screen: a plain key-value store that gains new requirements at each stage (TTL, transactions, scans). The signal is not stage 1, it is whether your code takes on stage 4 without a rewrite. Here is how to design for it.

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

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

A grounded systems-coding screen: locate files with identical content across a tree. The naive all-pairs hash wastes work. The signal is the size prefilter plus a cheap-hash gate ahead of the full hash. Here is the layered approach.

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

Sierra's signature build screen: cells hold values or formulas that reference other cells, and editing one has to 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 intentionally vague and shifts mid-interview. The signal isn't the algorithm, it's whether you clarify before coding, structure for change, and keep tests green as the requirements move. Here is how to run that loop.

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

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

Dijkstra computes 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 requires non-negative weights and how lazy deletion keeps the heap simple. Here is the answer.

Bellman-Ford copes with negative edge weights that break Dijkstra and detects negative cycles, the foundation of currency-arbitrage problems. The signal is the V-1 relaxation rounds plus 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 compact three-line triple loop. The signal is the intermediate-node DP order and why k has to be the outer loop. Here is the answer.

Kruskal builds a minimum spanning tree by sorting edges and adding the cheapest one 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 rather than backtracking the text. The signal is what the prefix function actually holds and why the text pointer never moves backward. Here is the answer.

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

Binary search on the answer cracks minimize-the-maximum and capacity problems by guessing the result and testing feasibility with 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 drive 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 through binary exponentiation. The signal is building the transition matrix and squaring it. Here is the answer.

A time-based key-value store logs 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 checks recursion plus the split criterion math. The signal is computing impurity correctly, picking the best threshold by information gain, and knowing the stopping rules. Here is a clean recursive implementation.

A from-scratch staple that checks whether you grasp 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 probes linear algebra fluency. The signal is centering first, using SVD instead of forming the covariance matrix, and reading variance off the singular values. Here is the implementation and the details interviewers push on.

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

A build-it-yourself check on the least-squares closed form and the numerical traps hiding in it. What matters is deriving the normal equations, understanding why you never invert explicitly, and reaching for lstsq or the SVD instead. The code follows.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

SVMs sort the candidates who memorized 'maximize the margin' from those who can explain how a kernel delivers non-linear separation without ever touching the high-dimensional space. Here is the answer that lands the second signal.

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

Dimensionality questions probe linear-algebra intuition and practical judgment together. What interviewers reward is what PCA really does (project onto max-variance directions), why high dimensions hurt, and the honest catch: it is unsupervised, so it can discard the exact direction your label needs. Here is the answer.

EM is the classic latent-variable algorithm, and a GMM is how it appears in practice. What interviewers reward is the E-step/M-step alternation, why it is soft clustering where k-means is hard, and the honest caveat that it only reaches 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.' What interviewers reward is the forward-then-backward flow and why it is efficient. Here is the answer.

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

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

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

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

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

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

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

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

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

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

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 can make or break a real-time voice agent.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

HMMs are the classic probabilistic sequence model behind speech and tagging, and Viterbi is how you decode them. What matters 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. What matters is knowing why zero init is fatal and how to match Xavier or He to your activation function.

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

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

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

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

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

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

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

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

Gaussian Processes give predictions with principled uncertainty, which is why they power Bayesian optimization. What matters 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. What matters is the message-passing mechanism, why k-hop matters, and why you keep them shallow. Here is the answer.

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

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

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

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

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

Wrap any model and obtain prediction sets with a provable coverage rate, with no distributional assumptions needed. What shows depth 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) conceal a twist that quietly biases ordinary regression. What shows depth is naming that twist and choosing the right framing. Here is the answer.

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

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

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

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

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

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

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

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

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

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

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

A small labeled set is the normal place to start, not an excuse. The strong answer is a ladder of techniques that pull signal from unlabeled data, pretrained models, and the labeling budget. Here it is.

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

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

Generative training breaks in distinctive ways: GANs collapse to a handful of outputs, diffusion samples come out noisy or blurry. The symptom points to which knob to turn. Here is the diagnosis.

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

In search and recommendation, A/B tests can be slow and noisy because they pit different users against each other. Interleaving compares two rankers inside the same user's results and spots winners with far less traffic. Here is how.

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

Most CV systems break at the seams: a preprocessing mismatch between training and serving, not the model itself. The signal is naming every stage from ingestion through serving and the single consistency invariant that trips teams up. Here is the answer.

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

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

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

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

A Gaussian mixture trained by EM has a well-known trap: one Gaussian shrinks onto a single point and the likelihood races to infinity. Understanding the cause, plus the three standard remedies, tells apart people who merely ran sklearn from those who grasp it.

Both label sequences, but one is generative and one is discriminative, and that gap decides whether you can add overlapping features. Here is the comparison that proves you understand the modeling tradeoff, not merely the acronyms.

Anyone can say 'ensemble of trees'. The real answer concerns decorrelating those trees and why that, not averaging alone, 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 carrying a real tradeoff. Here is what they do and where they hurt.

Bayesian inference requires an intractable normalizing constant, and MCMC works around it. The signal is explaining the acceptance ratio, detailed balance, and why you can drop the constant entirely. Here is the answer.

The 'naive' independence assumption is wrong on real data, yet the classifier remains 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 picking k, why distances lose meaning in high dimensions, and how to keep prediction fast on millions of points. Here is the tradeoff-aware answer.

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

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

Lasso delivers sparsity, Ridge copes with correlated features, and each stumbles where the other excels. Elastic Net combines them for a specific, common failure. Here is when it earns its two hyperparameters.

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

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

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

Both explain one prediction by crediting features, but only one is backed by a uniqueness theorem. What interviewers reward is knowing SHAP's game-theory guarantees, LIME's instability, and when each fits. Here is the answer.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Modern warehouses store JSON natively, and querying it well sets strong data engineers apart 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.

WHERE cannot reference a window function, so people resort to wrapping queries in subqueries. QUALIFY filters on window output directly. The signal is explaining why WHERE fails and writing top-N-per-group cleanly.

Modern table formats can query a table as of an earlier version or timestamp, the foundation of reproducibility, audits, and recovery. The signal is the versioned-snapshot mechanism and where it falls apart.

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

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

Pick the wrong partition key and you end up with millions of tiny files or lopsided giants. The signal is partitioning on a low-cardinality filter, clustering inside partitions on the next predicate, and keeping an eye on file size.

At-least-once creates duplicates and at-most-once drops data; everyone asks for exactly-once yet few can explain how Kafka provides it. The signal is idempotent producers, transactional read-process-write, and the read-committed isolation that binds them together.

When a metric looks off, lineage points you to the upstream table at fault. The signal is separating table from column lineage and knowing the three capture methods: SQL parsing, runtime hooks, and metadata APIs.

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

Pulling a scalar by path is easy; an array of objects three levels deep is where people freeze. The signal is LATERAL FLATTEN / UNNEST to explode arrays into rows plus a clear rule for when to flatten versus query in place.

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

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

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

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

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

Text-to-SQL is deceptively hard because correctness is all-or-nothing and the failure mode is a confident wrong number. What interviewers reward: schema grounding, query validation, and a safety layer, not merely 'prompt an LLM with the schema.' This lays out the production design.

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

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

Anomaly detection seems simple until seasonality, cold start, and alert fatigue arrive. The signal is modeling the expected baseline (including weekly and daily cycles), picking unsupervised methods when labels are scarce, and tuning so you do not bury 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 at 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 keeping cost and latency bounded. 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 rather than a bigger context window. The signal is the tiered architecture plus what to store, forget, and protect.

AI code review succeeds or fails on precision: a handful of noisy comments and the team silences the bot for good. The signal is grounding in the diff plus repo context, unforgiving false-positive control, and winning developer trust one accepted comment at a time.

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

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

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

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

Document extraction (IDP) is a massive enterprise use case with a steep correctness bar: a wrong extracted number beats having none. The signal is the parse, extract, validate, human-review pipeline plus confidence-based routing. Here is the design.

A voice assistant links STT, an LLM, and TTS under a punishing latency budget where each stage piles on 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 injure a patient, and regulators are paying attention. 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 carries real consequences, and lawyers have been sanctioned over fabricated cites. The signal is grounding in the actual documents, citing exact passages, and lawyer-in-the-loop. Here is the design.

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

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

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

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

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

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

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

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

The trap is swapping the classifier for an LLM. The real-time, imbalance, and adversarial constraints stay put. 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 draw candidates from millions of items in milliseconds. The signal is why the user and item towers stay separate, how that enables precomputed embeddings plus an ANN index, and where ranking takes over.

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

ETA is spatiotemporal regression served in real time over conditions that shift 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 testing for one instinct: do you generate candidates from the social graph, or naively try to score every pair? Here is the design that holds up through the follow-ups.

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

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

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

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

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

Some questions need precise multi-hop facts that vector retrieval cannot 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.

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

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

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

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

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

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

Two forces shape 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 reverse of low-latency serving. Every choice that harms latency works in your favor here. Here is how to design for dollars-per-million-documents.

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

'What was revenue by region last quarter?' looks like text-to-SQL, yet production analytics agents break 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 capped by the source uplink and scales linearly. The answer interviewers reward turns receivers into senders so the swarm's capacity grows with its size. Here is that reasoning.

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

Every API platform needs one. Interviewers reward the candidate who picks the right algorithm (token bucket vs sliding window) for the burst behavior, then cracks the genuinely hard part: holding 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 keep traffic off a dead server, and how does the load balancer itself avoid being a single point of failure? Interviewers want the algorithm, the health-check loop, and the high-availability story.

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

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

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

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

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

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

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

Detecting the language of a string seems trivial until the input is three words, blends two languages, or is half code. A strong answer chooses the model by latency budget, handles short text and code-switching, and returns calibrated confidence rather than 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 weighs spectrogram masking against waveform models under a real-time budget, names PESQ and STOI as the metrics, and stays honest about the artifacts each approach brings.

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

Enterprise search lives or dies on permissions, freshness, and wiring into 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 wins out, and how to evaluate summaries at scale.

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

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

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

Running experiments on LLM features is tough because outputs are open-ended and quality is fuzzy. See how to assign traffic, choose metrics beyond engagement, tame variance from non-determinism, and dodge the traps that let a winning variant lose once it ships.

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

A rider taps request and within seconds a nearby driver gets 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, per-host politeness, dedup across billions of URLs, and defenses against spider traps and infinite content. Here is the crawler architecture that scales without getting your IPs banned.

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

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

The LLM is the easy part. The system is a learner model: a skill graph, a per-student mastery estimate, and an item selector that keeps the student at the edge of their ability. Here is the design, including the pedagogical constraint most candidates miss.

Every AI system spends quality to buy speed, whether or not the team admits it. What scores is knowing the exchange rate for each knob, taking the free wins first, and having already decided what you will sell when the system saturates.

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

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

Trust is an interface and reliability problem, not a messaging one, and the goal is not maximum trust. Here is the mechanism list that actually moves it, the recovery path after a public failure, and the metric most teams optimize in the wrong direction.

Every AI product that runs generated code (notebooks, agents, code interpreters) ends up building this, and the interview turns on two numbers: how strong your isolation is and how fast a session starts. The answer is microVMs plus snapshot restore, and knowing why the VM boot is not the slow part.

The rookie reply is 'retrain weekly.' The experienced call is a hybrid: drift-triggered retraining backed by a max-staleness fallback, plus a gate requiring any new model to beat the incumbent. Here is how to think it through.

A feature store is simple to define and simple to botch. The signal is naming the precise bug it prevents (training-serving skew) and the point-in-time correctness that blocks label leakage. Here is the full picture.

The trap is describing ordinary software CI/CD. The signal is the three additions ML brings: data validation, a model-quality gate against a baseline, and versioning data plus model plus code as a unit. Here is what truly differs.

At thousand-GPU scale, hardware failure is routine rather than rare, and a run that cannot resume burns weeks. The signal is checkpointing strategy, deterministic resume, and holding lost work to a minimum. Here is the fault-tolerant design.

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

Deploying a model is more than flipping a switch. The signal is knowing what each rollout strategy validates, why shadow is uniquely useful for ML, and keeping rollback a single step away. Here is the comparison and when each fits.

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 wisely, and how to parallelize without stragglers.

GPU spend is typically the largest line item in an AI org, and this question tests whether you reason in utilization rather than just capacity. The signal is wringing out per-unit cost (utilization, right-sizing, spot, quantization) before scaling out.

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

LLMOps is not MLOps with bigger models. What counts 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. What counts is the actual statistical methods and separating 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. What counts 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,' guessing is a failing answer. What matters is tracking the entire chain so any model can be reproduced and any past decision explained. Here is the chain.

Not every prediction needs a low-latency endpoint, and reaching for one by default wastes money. What matters is matching the serving pattern to the latency and freshness requirement. Here is the decision and when you'd reverse it.

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

A bad model in production needs a fast, safe rollback, but ML rollback is harder than code: the model is data and the truth signal lags. What matters 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. What matters is knowing outputs run in parallel then get 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. What matters is the DAG/scheduling model plus what's genuinely ML-specific: data deps, versioned artifacts, drift triggers, eval gates.

Monitoring an ML system goes past CPU and latency; the model can silently rot while the dashboard stays green. What matters 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 cause is almost always a feature computed differently across the two paths. Here is the diff-based hunt that localizes it to a single column.

Regulators and customers will ask 'Why was I denied?', and 'we retrained since then' will not satisfy them. Reproducing a prediction exactly requires versioning everything. This spells out what 'everything' really covers.

Automated retraining seems like a convenience right up until an auto-retrained model quietly ships worse. The gates are the entire point. Here is how to automate retraining without automating a regression straight into production.

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

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

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

'Just set a seed' misses the point. Reproducibility means pinning the environment, the data, the code, and the hardware-level nondeterminism together. Here is the full checklist and where it springs leaks.