Medium Applied AI interview questions

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

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

Every customer asks how to stop the model making things up. The weak answer is 'better prompts.' The signal is knowing why models hallucinate and layering grounding, abstention, and measurement into a system you can defend.

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

What each knob does to the next-token distribution, why top-p adapts to confidence where top-k does not, and why factual and creative tasks want opposites.

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

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

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

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

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

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

The difference between a demo prompt and a production prompt is structure, versioning, and defense. The signal is treating the system prompt as a contract and templates as parameterized, testable artifacts. Here is the answer.

Complex tasks rarely fit one prompt, and free-text LLM output rarely plugs into code cleanly. The signal is decomposing into chained steps and parsing each output. Here is the answer that connects prompting to real pipelines.

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

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

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

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

Fine-tuning is mostly a data problem, not a hyperparameter one. The signal is naming what makes a good set (quality, diversity, format, dedup) and arguing why a few thousand clean examples beat a million noisy ones.

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

Offline metrics gate releases on a fixed dataset, online metrics show what users actually did, and offline wins routinely fail to hold. Why you need both.

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

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

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

This is an architecture and business decision, not a religious one. The signal is weighing capability, cost, privacy, control, and operational burden, then making a call instead of declaring 'open is always better.'

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

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

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

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

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

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

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

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

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

The senior signal is matching the method to what is actually missing instead of defaulting to your favorite. Knowledge, behavior, or actions each point at a different tool. Here is the decision framework that scores highest.

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

Token count is latency and dollars, not just style. 'Be concise' barely works, and max_tokens just truncates mid-sentence. Here is how to actually shape length without amputating answers.

The training cutoff is frozen but dependencies move weekly. Retrieve the installed docs and lockfile, let the linter drive a fix loop, and skip retraining.

Neural text degeneration is a known failure of likelihood-maximizing decoding, not a broken model. The fixes are specific decode-time knobs. Here is which lever to pull and what each one costs.

Generation has to stop somewhere, and the wrong stop rule either truncates answers or burns tokens on trailing garbage. Here is how the EOS token, stop strings, and max-token caps actually interact.

A model that scores 92% on your eval can still ship a product users hate, because the model is one component in a system. Teams that only do model evals get blindsided. Here is the distinction that matters.

Pairwise asks which is better, pointwise asks how good. The signal is knowing which is more reliable, how Elo/Bradley-Terry aggregates comparisons, and where each method quietly misleads.

The same model can score ten points apart on MMLU depending on prompt format and scoring method. The signal is knowing the knobs (log-prob vs generation, few-shot, normalization) that make evals reproducible.

GGUF is the format behind most local LLM runs, and its quant names look cryptic. The signal is decoding what Q4_K_M means and why mixed-precision k-quants beat naive uniform quantization.

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

The two knobs that make or break a RAG system, and the ones candidates hand-wave. The signal is tuning chunking against recall and knowing exactly what dense retrieval misses that BM25 catches. Here is the reasoning, not the rules of thumb.

Agents and integrations live or die on the model returning valid, schema-conforming output. The signal is layering constrained decoding, schema validation, and retries, not hoping a prompt is enough. Here is the production-reliability answer.

Every RAG system rests on a vector index, and the interviewer wants to know you understand the recall/latency/memory tradeoff, not just 'use a vector DB.' The signal is why exact search does not scale and how HNSW and IVF make different bets.

MCP standardized how agents plug into tools and data, but tool design is what makes or breaks reliability. The signal is knowing what MCP actually standardizes and the principles behind a tool the model can call correctly from its description alone.

Reflection is the pattern where an agent critiques and revises its own work. The signal is knowing when it genuinely helps (external feedback grounds the critique) versus when self-critique alone is theater.

Chunking quietly sets the ceiling on RAG quality, and 'split every 500 tokens' leaves recall on the table. The signal is knowing the strategy families and the parent-child trick that decouples retrieval size from context size.

Citations turn a RAG answer from 'trust me' into something verifiable, and they are a real engineering problem. The signal is grounding each claim to a specific passage and verifying the attribution, not appending a bag of links at the end.

Plan-and-Execute and ReAct are the two dominant agent control patterns. The signal is knowing the upfront-plan vs step-by-step tradeoff, why one is cheaper, and why most production agents end up blending them.

Agents need memory beyond the context window, and 'just store the history' is the wrong answer. The signal is distinguishing the memory types and mapping each to a storage and retrieval strategy. Here is the answer.

Context engineering is the discipline that replaced 'prompt engineering' for serious agent work. The signal is understanding that what you put in the context window (and what you leave out) drives behavior more than clever wording. Here is the answer.

The embedding model is the foundation of retrieval, and swapping it is deceptively dangerous. The signal is choosing on domain-relevant retrieval quality (not leaderboard) and knowing that a new model means re-embedding everything. Here is the answer.

Tool selection and parameter extraction are where agents quietly fail. The strongest answer treats the tool spec as the only thing the model sees, then fixes the design, not the model. Here is how.

Dense vs sparse is the core retrieval tradeoff, and 'just use embeddings' silently loses every exact-match query. The signal is knowing what each representation captures and why production blends them. Here is the answer.

Sub-agents are how you scale a complex agent task without one giant, noisy context. The signal is context isolation and clean delegation: a focused subtask in, a compact result out. Here is the answer.

Multi-agent systems live or die on how agents share information and hand off work. The signal is naming the three communication patterns and the coordination failures that sink the naive version. Here is the answer.

Garbage parsing means garbage retrieval, and naive PDF text extraction destroys tables and reading order. The signal is fixing the parser, not the retriever. Here is the answer.

The same model performs wildly differently depending on the harness around it. The signal is knowing that the scaffolding often decides agent quality more than the base model. Here is the answer.

RAG and agents get expensive and slow fast: retrieval plus reranking plus big-model calls, multiplied across agent steps. The signal is naming the dominant cost first, then the levers that actually move it. Here is the playbook.

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

Pure vector search misses exact terms; pure keyword search misses meaning. The signal is knowing why each fails alone and how to merge two rankings on incomparable scales without hand-tuning weights. Here is the answer.

A RAG system is only as current as its index, and stale or duplicated content silently degrades answers. The signal is an incremental pipeline with deletes, updates, and recency signals, not a one-time bulk load. Here is the answer.

Forcing every query through the same pipeline burns latency, money, and precision. A router decides what each query actually needs. The signal is naming the four decisions a router makes and how you keep a misroute from sinking the answer.

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

Small chunks match precisely but starve the LLM of context; big chunks have context but match badly. Parent-child retrieval refuses to pick. The signal is decoupling what you match on from what you feed the model.

A chunk embedded in isolation forgets which document, section, and entity it came from, so it retrieves poorly. Contextual retrieval writes that context back in before indexing. The signal is fixing retrieval at index time, not query time.

Fixed-size chunking splits a coherent idea mid-thought; semantic chunking splits on meaning. The signal is naming the methods (structure-aware, embedding-similarity, LLM-based) and the tradeoffs that decide which one to ship.

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

RAG failures are usually retrieval failures, yet most teams only measure the final answer. The signal is scoring retrieval on its own (recall@k, precision@k, MRR/nDCG) to isolate exactly where the system breaks.

Top-k by pure similarity often hands the model five paraphrases of the same paragraph, starving it of the other facts the question needs. The fix is ranking for relevance and novelty at once. Here is how.

Real users type 'what about the new policy?' with no context. Retrieving on those four words returns noise. Here is how strong systems disambiguate before they ever hit the retriever.

More chunks means higher recall but more noise, more cost, and more lost-in-the-middle. The right k is an empirical tradeoff, not a default of 5. Here is how to find it.

Frameworks promise speed and deliver abstraction you'll eventually fight. Rolling your own is more code but full control. Here is the honest tradeoff, and why many production teams end up thinner than they started.

The industry conflates 'agent' with anything that calls an LLM. The useful distinction is how much control you hand to the model, and more autonomy is not better. Here is the spectrum and the decision rule.

A bridge between classic DSA and modern RAG. The signal is building a working inverted index and a correct BM25 score by hand, reasoning about its complexity, and then knowing exactly when you would reach for embeddings and an ANN index instead.

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

An answer can be correct and still unfaithful, stating things the retrieved context never said. The signal is scoring faithfulness against the context, not against truth, and knowing why LLM-judge faithfulness scores drift.

Cranking up top-k raises recall but drowns the answer in noise, and a tight reranker raises precision but can drop the one chunk you needed. The signal is knowing which metric caps the system and how to move both with a retrieve-wide-then-rerank shape.

Tools fail: timeouts, rate limits, bad arguments, garbage output. A naive agent retries blindly or gives up. The signal is classifying errors and matching each to the right recovery, with hard caps.

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

Autonomous agents still need humans at the right moments. The signal is designing checkpoints: where to interrupt, what to surface, how to persist and resume state, without turning the agent into a click-through rubber stamp.

Agents re-send growing context every step, so cost scales worse than linearly. The signal is knowing where the tokens go and the levers (caching, model routing, context trimming, step caps) that cut the bill.

Every tool definition costs context and adds a wrong option. Past a couple of dozen tools, selection accuracy falls and the fix is choosing a smaller loadout per task, not writing better descriptions.

A favorite practical screen at the labs, because it tests concurrency, time handling, and judgment in 20 lines. The trap is the background thread that wastes CPU. Here is the lazy-refill version interviewers want, plus the follow-ups.

A staple ML-coding screen. Writing the loop is easy; the signal is k-means++ init, a real convergence criterion, and knowing the failure modes. Here is the tight implementation plus the follow-ups interviewers always ask.

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

Hashmap for lookup, doubly linked list for recency, move-to-front on access, evict at the tail. Then the usual follow-ups: TTL and thread safety.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Rotating a matrix in place tests index manipulation and the transpose-then-reverse trick. The signal is decomposing the rotation into two simple passes rather than juggling four-way swaps. Here is the answer.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Every chat model's 'temperature' and 'top_p' knobs are a few lines of logit surgery. Implementing them shows you understand decoding, not just call it. Here is the from-scratch version.

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

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

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

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

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

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

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

Two lists that share a tail must intersect at a single node, but matching their lengths without counting is the elegant move interviewers want. Here is the two-pointer trick that makes the lengths cancel out, plus the answer.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Sieving primes, fast modular power, and Euclid's gcd are the number-theory primitives that quietly power crypto, hashing, and combinatorics problems. The signal is the O(n log log n) sieve and O(log e) binary exponentiation. Here is the answer.

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

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

Fit a mean and variance per class per feature, sum log-likelihoods with the log prior, argmax. Why log space, and what conditional independence buys you.

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

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

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

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

A from-scratch test of distributed input pipelines. The signal is partitioning data across workers with no overlap and no gaps, epoch-consistent shuffling with a shared seed, and handling the uneven-last-batch problem. Here is the implementation.

The most job-shaped coding screen in Applied AI: fan out N LLM calls without melting the rate limit or losing the batch to one bad request. The signal is in the retry policy, not the async syntax. Here is the version that passes.

The coding round version of the RAG question every candidate can describe in prose. Embed, index, retrieve, generate, cite. What separates a pass from a fail is the branch you write for when retrieval comes back with nothing worth quoting.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

This question ties together why deep nets were hard to train and the cluster of tricks that fixed it. The signal is the multiplicative-gradient cause and naming the real fixes: ReLU, He/Xavier init, residuals, normalization. Here is the answer.

CNNs are foundational even as transformers rise, and this checks whether you understand why convolution suits images. The signal is parameter sharing and local connectivity, what pooling buys, and how the receptive field grows. Here is the answer.

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

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

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

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

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

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

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

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

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

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

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

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

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

Too high and the loss diverges to NaN, too low and it stalls. Warmup ramps up to survive the early steps, decay anneals down to settle. What each fixes.

Ranking is not classification, so accuracy is the wrong tool. The signal is matching the rank-aware metric to the task: one right answer versus many, binary versus graded relevance. Here is the answer.

A staple that checks whether you know why ReLU dethroned sigmoid and how to match the output activation to the loss. The signal is the vanishing-gradient story told correctly. Here is the answer.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

A model can rank perfectly and still lie about its probabilities; its 0.9 may be right 70% of the time. The signal is knowing the three fixes, which data size each needs, and how to measure the gap. Here is the answer.

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

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

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

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

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

Accuracy ties are common, and accuracy is rarely the deciding factor anyway. The real tiebreakers are the ones a junior candidate forgets to mention. Here is the checklist a staff engineer runs before shipping either one.

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

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

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

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

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

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

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

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

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

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

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

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

Expire the current row and insert the new one in one MERGE INTO, using the staged-double-row trick so close and open commit atomically and reruns are safe.

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

Rank inside a PARTITION BY and filter to rank <= N. The function you pick decides how ties behave, plus the window frame for a running total per group.

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

A data-warehouse fundamentals question that separates people who model for analytics from people who only know OLTP normalization. The signal is facts vs dimensions, the star schema, and why analytics denormalizes where transactional systems normalize.

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

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

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

Query tuning is a core data-engineering skill, and the signal is reading the execution plan before changing anything, then applying the right fix. Here is the diagnostic method that separates guessers from engineers.

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

Hierarchies (org charts, bill-of-materials, category trees) need recursion, and a self-join only goes one level deep. The signal is the recursive CTE with its anchor plus recursive members, and knowing how it terminates.

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

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

The subtlety in rolling aggregates is the window frame clause, especially ROWS vs RANGE. The signal is the correct frame for a moving window and the tied-rows gotcha that corrupts running totals.

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

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

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

Materialized views trade storage and freshness for query speed by precomputing results. The signal is knowing the view-vs-materialized-view tradeoff and the refresh/staleness question.

Time-based analysis is everywhere in analytics, and time zones and bucketing are the common traps. The signal is DATE_TRUNC for bucketing, interval math, and storing UTC.

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

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

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

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

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

MERGE handles insert-or-update-or-delete in one statement, the backbone of incremental loads and slowly-changing dimensions. The signal is the matched/not-matched logic and what makes a retry safe.

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

You don't always need a dedicated vector database. When embeddings live next to your relational data, nearest-neighbor in SQL makes filters and joins trivial. Here is how, and the scale where it breaks.

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

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

Days with zero events simply don't appear in an event table, so a 7-day average silently averages the wrong 7 rows. A date spine makes the missing days explicit. Here is the pattern.

The applied data-wrangling screen: here is a grubby database, produce a clean analysis-ready table. The signal is profiling before transforming, doing set-based cleaning in SQL and row-level fixes in Python, joining without fanning out rows, and validating the output instead of trusting it.

Wide tables with a column per period are painless to read and painful to query. The signal is unpivoting to long format with UNPIVOT or a UNION/cross-join trick, and knowing how NULLs and types bite you.

Downstream pipelines break when an upstream team renames a column at 2am. The signal is a data contract: an enforced, versioned agreement on schema and semantics, checked at the producer before bad data spreads.

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

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

Back-of-the-envelope for LLM serving, done properly. The arithmetic is four numbers deep and it usually kills the plan it was asked to justify, which is exactly why interviewers ask it.

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

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

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

A high-AUC churn model that changes no behavior is worthless. The strong answer nails the label definition, picks classification vs survival deliberately, and is judged on retention uplift, not accuracy.

Sales has finite rep-hours, so the model's job is to point them at the leads worth a call. The signal interviewers want is value-weighted prioritization, careful conversion labels, and proof of revenue uplift over a holdout.

Prompts buried in source code mean every wording tweak is a full deploy, and nobody knows which prompt is live. Treating prompts as managed, versioned configuration is the fix. Here is the platform.

Give every team an LLM API key and your bill becomes a mystery with a six-figure surprise at month end. Attributing, limiting, and optimizing spend is a platform feature. Here is how to build it.

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

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

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

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

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

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

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

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

The trap is jumping straight to 'add more GPUs.' The signal is profiling first, then applying the cheap, no-retrain levers in the right order. Here is the diagnosis-then-optimize playbook for p99.

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

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

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

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

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

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

You cannot improve an LLM app you cannot see into, and LLM observability is not service monitoring. The signal is tracing multi-step chains, capturing inputs/outputs/tokens/cost, and online quality signals, not just latency and errors.

Caching is one of the biggest LLM cost levers, but 'cache the response' is naive for a non-deterministic system. The signal is distinguishing prompt (prefix) caching from semantic caching and knowing when each is safe.

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

Routing each request to the right model is one of the biggest LLM cost/latency levers in production. The signal is matching query difficulty to model capability and knowing when the cascade pattern beats a classifier.

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

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

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

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

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

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

AI systems get expensive fast, and 'the GPU bill is huge' is not actionable without attribution. The signal is breaking spend down by model, feature, team, and request, then naming the levers. Here is the answer.

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

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

Champion-challenger is how you improve a production model without betting the business on a hunch: the live model versus candidates competing on real metrics. The signal is the ongoing-competition framing and disciplined, pre-committed promotion.

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

'Which model is in prod right now, and how did it get there?' should be a one-second lookup with an audit trail. If it isn't, you have a rollback and compliance problem already. Here is the promotion pipeline.

A data engineer renames a column and three production models silently start scoring on garbage. Features are a shared contract, and changing them needs the same care as a breaking API change. Here is the discipline.

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

'Works on my machine' is a dependency and environment problem, and for ML it includes CUDA versions and exact library pins that change numerical results. Here is how to make the production environment match training.

You cannot put a 2 TB dataset in git, and copying it per experiment bankrupts you. The signal is knowing how content-addressed versioning works and when file-level (DVC) versus branch-level (lakeFS) fits. Here is the decision.

Anyone can wire tasks into a DAG. The signal is the patterns that keep it correct under retries and backfills: idempotency, data-aware triggering, and the asset model. Here is what separates a flaky pipeline from a trustworthy one.

Three drifts get casually lumped together, but they have different detectability and different fixes. The interview signal is knowing which you can catch without labels and which one genuinely demands a new model.

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

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

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

A Deployment and a Service will serve a model, but GPUs break every Kubernetes default: scheduling, probes, autoscaling signals, and rollouts. Here is the setup that survives production, and when KServe earns its complexity.

Knowing the algorithms is half the job. The other half is the serving stack that actually delivers throughput inside a latency budget. The signal is matching the server to the workload and naming the four knobs that move the needle.

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

Continuous batching is the single biggest throughput lever in modern LLM serving. The signal is explaining why static batching idles the GPU on variable-length generation, and why PagedAttention is what makes the fix practical.

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

Picking GPUs is a real applied decision, and 'get the biggest one' misses the point. The signal is knowing which spec binds your workload (VRAM, bandwidth, interconnect) and the train-versus-serve difference that flips the answer.

Autoscaling GPUs is not autoscaling web servers: GPUs are scarce and expensive, model loading is slow, and the right signal is not CPU. The signal is scaling on queue and GPU metrics, taming cold starts, and the scale-to-zero economics.

Under load, a shared inference service must decide whose request runs now. The signal is queuing with priorities, backpressure, and fairness wired into batching, not first-come-first-served until the service falls over.

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

LLM serving has its own metrics, and one latency number hides the real bottleneck. The signal is splitting prefill from decode and reading GPU utilization as a clue, not a verdict. Here is the diagnostic toolkit.

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

These four get conflated constantly, but they live at different layers: data processing, distributed training, and general orchestration. The signal is matching the tool to the workload instead of reaching for the one you know. Here is the answer.

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

You rarely write a serving stack from scratch. The signal is knowing what frameworks hand you (batching, multi-model, GPU scheduling) and why LLM-specific servers exist at all when general ones already batch.

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

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

Launching an LLM service on a vibes-based GPU count is how you get paged on day one. Capacity planning for LLMs differs from web services because tokens, not requests, are the unit. Here is how to size it.

Three batching strategies, three very different latency profiles. Picking wrong leaves throughput or tail latency on the floor. Here is what each one costs and when to use it.

A classic ML-security question that catches people who only know clean-data accuracy. The signal is understanding why models are brittle, the realistic threat model, and that no single defense holds. Here is the honest answer.

LLM endpoints are uniquely exposed: each call can cost real money and burn scarce GPU capacity, and abuse is both a security and a financial problem. The signal is layered controls on tokens and cost, not just requests. Here is the defense.

Governance is where enterprise AI deals are won or lost, and engineers who can speak it stand out. The signal is treating it as documentation, accountability, and risk-tiered controls across the lifecycle, not a legal afterthought.

Regulators and enterprises increasingly demand explanations for AI decisions, and the two terms get used loosely. The signal is separating inherently interpretable models from post-hoc explanations and naming the right technique for the stakes.

Red teaming is how you find an AI system's failures before users or attackers do. The signal is a structured program covering the real attack surface (jailbreaks, harmful content, leakage, bias) and feeding every finding back into defenses.

The NIST AI RMF is the most-referenced voluntary framework for managing AI risk, and enterprises ask about it. The signal is treating it as a continuous process built on four functions, not a compliance checklist. Here is the answer.

Copyright is one of the biggest unresolved risks in generative AI, on both the training and output side. The signal is naming both exposures and the engineering mitigations for each, not offering a legal opinion. Here is the engineer's framing.

As generation gets indistinguishable from real, knowing what is AI-made matters for trust, misinformation, and regulation. The signal is the split between in-content watermarks and attached provenance metadata, and that detection is an arms race. Here is the answer.

AI fails in ways traditional software does not: bias, hallucination, harmful output, silent quality regression. The strong answer is a real playbook (detect, contain, communicate) plus a blameless post-mortem that ships systemic fixes. Here is the answer.

Detection is imperfect, so the strong answer is layered: regex with checksums for structured PII, ML/NER for the unstructured PII regex cannot see, and a frank account of why you never rely on redaction alone. Here is the answer.

Model cards and datasheets are the standard responsible-AI documentation artifacts, increasingly required by regulation and buyers. The strong answer knows what each documents and that honest disclosure of limitations, not marketing, is the entire point. Here is the answer.

'Add guardrails' is hand-wavy. The strong answer names the concrete input and output checks, the mechanisms that enforce them, and the fail-safe behavior when one trips, plus the honesty that they are imperfect. Here is the implementation answer.

Models hand back confident answers on inputs unlike anything they trained on, which is how silent production failures happen. The signal is knowing why raw softmax confidence lies and which detectors actually separate in- from out-of-distribution.

Attackers coax models into dumping the hidden system prompt, exposing IP, business logic, or worse, embedded secrets. The signal is treating the prompt as non-secret and defending in layers, not betting on 'never reveal your instructions.'

Toxicity detection looks like vanilla text classification and is anything but: context flips labels, adversaries evolve weekly, and naive models flag dialects as hate. The signal is naming those failure modes and designing the human-in-the-loop system around them.

The EU AI Act tiers obligations by risk, and that classification is a first-order design decision, not a legal footnote. The signal is knowing the four tiers and what high-risk systems must prove before they ship.

Audit logging is the backbone of AI accountability, but logging everything naively turns your logs into the biggest privacy liability you own. The signal is what to log to replay any decision, and how to do it without hoarding PII.

Safety is not one number. The candidates who pass name the axes, run benchmarks as a gate, and then explain why benchmarks alone certify nothing. Here is the framing interviewers score highest.

Every third-party model, dataset, and library is an attack surface: backdoors, poisoning, arbitrary code on load, license landmines. The signal is treating models and data as supply-chain artifacts that need provenance and vetting. Here is the answer.

LLM apps leak secrets in three quiet places: the prompt, the logs, and the next training set. Each needs a different control. Here is how to close all three.

An attacker doesn't need to breach your LLM to hurt you, just make it do expensive work. A handful of crafted prompts can pin your GPUs and run up the bill. The defense is not a bigger rate limit.

C2PA cryptographically signs where media came from, but a signature you can strip is not the same as a watermark you cannot. The signal is knowing what provenance proves, what it does not, and why you pair it with watermarking. Here is the answer.

ISO 42001 is the certifiable AI management-system standard, the AI analogue of ISO 27001. The signal is knowing it is an auditable management system, not a technical control list, and how it sits next to NIST and the EU AI Act. Here is the answer.

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

Adopting a vendor model imports their data practices, security, and failure modes into your product. The signal is a structured assessment covering data handling, security, performance, and contractual terms, not just a demo that looked good. Here is the answer.

This question is not about whether you failed; everyone has. It is a test of ownership, debugging rigor, and honesty under pressure. Here is the structure that turns a failure story into a hire signal, and the traps that turn it into a flag.

Every loop has this question and most answers fail in one of two ways: too combative or too much of a pushover. The signal is data-driven persuasion plus genuine disagree-and-commit. Here is the arc that lands and the traps that sink it.

Applied AI is half translation. Interviewers ask this to see whether you can drop the jargon, frame tradeoffs in business terms, and earn trust with people who control the roadmap. Here is how to show that skill in the answer itself.

This is a full interview round (OpenAI's project deep dive, Amazon's Tech Talk), not small talk. It is where they test whether you actually understand the work you claim. The signal is depth, your specific contribution, and the tradeoffs you can defend. Here is how to prepare and deliver it.

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

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

AI moves fast enough that learning speed is a core competency, and several companies ask it directly. The signal is a concrete method for ramping fast and a real, recent example of applying something new. Here is how to show learning agility, not just claim it.

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

This question screens ego and growth, not perfection. The interviewer wants to see you absorb hard feedback without defending, own a real mistake in first person, and change because of it. The signal is humility plus a durable, concrete change.

At the frontier labs this is a real gate, not a pleasantry. They reject strong engineers who cannot articulate genuine motivation. The signal is specific, honest alignment between what you want to build and what this company actually does.

Mentoring questions test whether you scale beyond your own output, a senior and leadership signal. The interviewer wants a real example with a tailored approach and a measurable outcome, not 'I helped a junior.'

Strong applied-AI engineers are known for NOT reaching for ML when they shouldn't. The signal is judgment: ML earns its complexity only under specific conditions, otherwise rules and heuristics win.

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

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

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

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

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

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

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

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

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

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

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

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

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

Applied AI work is cross-functional: you ship with PMs, engineers, and domain experts. This probes whether you collaborate effectively across boundaries. The signal is bridging different goals and languages toward a shared outcome. Here is the arc.

Giving hard feedback well is a maturity and leadership signal. Interviewers want candor delivered with care that actually changed behavior, not avoidance and not bluntness. Here is the arc that lands.

Real work means more demands than time, often from stakeholders who each think theirs comes first. This probes how you prioritize and communicate. The signal is prioritizing by impact transparently, not just working harder.

AI moves fast, requirements shift, and tools change monthly. This probes adaptability. The signal is embracing the change, learning quickly, and adjusting course productively, not resisting it. Especially relevant for applied AI.

Saying no well is a senior signal: protecting quality, scope, or users without damaging the relationship. The signal is principled pushback with reasoning and an alternative, not just refusal. Here is the arc.

Defining the right metric is a high-judgment skill, and in AI the offline number and real impact routinely diverge. The signal is a metric tied to outcomes and guarded against gaming. Here is the arc.

AI features are probabilistic, and stakeholders hear 'it works.' Setting honest expectations without killing enthusiasm is a core applied-AI skill. Here is how to frame reliability so trust survives the first mistake.

Hype sets customers up to expect a system that reads minds and never errs. Resetting that without losing the deal is an applied-AI skill interviewers probe directly. Here is the move.

In an AI company, recommending against AI is a strong signal: it shows judgment over hype. Interviewers use this to find engineers who solve problems rather than apply a favorite hammer. Here is how to tell it.

AI features fail in public, sometimes embarrassingly. How you respond to the customer, not just the bug, is what this question is really testing. Here is the recovery that rebuilds trust.

Every AI team feels the pull between velocity and doing it responsibly. How you navigate that tension, with judgment rather than dogma in either direction, is what this question screens. Here is the answer.

Most AI pilots fail not on the model but on scoping: vague success criteria, the wrong use case, or data that was never ready. For forward-deployed and applied roles, running a pilot well is the job. Here is the playbook.

Chasing every new model is as bad as ignoring them all. Interviewers want a repeatable filter for signal versus hype, and the discipline to evaluate on your own problem. Here is that filter.

The model can be excellent and still fail if the people who must use it don't trust it. Adoption is change management, not a better demo. Here is how forward-deployed engineers actually earn it.

An angry customer is a test of composure and ownership, not just empathy. Interviewers want to see you de-escalate, fix the real problem, and rebuild trust. Here is the arc that scores.

Scope creep quietly kills deployments and burns trust on both sides. Interviewers want to see you protect the timeline without becoming the team that says no to everything. Here is the move.

Distributed, cross-cultural work is the default for forward-deployed roles. Interviewers want to see deliberate async habits and cultural awareness, not heroics. Here is what scores.

Executives buy outcomes and care about risk, not your architecture. Interviewers want to see you lead with the decision, quantify in their terms, and surface risk honestly. Here is the pattern.

When everything is urgent, the skill is a defensible triage and honest communication to whoever loses. Interviewers want a framework and the courage to say no clearly. Here is the move.

A good postmortem fixes systems, not people. Interviewers want to see you separate human error from system failure and produce real prevention. Here is how to lead one that scores.

Vague asks are the norm in forward-deployed work. Interviewers want to see structured discovery that finds the real problem and a measurable first win, not a rush to build. Here is the method.

Building it is not adopting it. Interviewers want to see you win a beachhead, prove value, and let advocates spread it, not mandate usage from the top. Here is the playbook.

A forward-deployed engagement succeeds only if the customer can run it without you. Interviewers want enablement and a real handoff plan, not a dependency. Here is how to build self-sufficiency.

Security and compliance teams are gatekeepers, not adversaries. Interviewers want to see you engage them early, meet real requirements, and turn a blocker into an ally. Here is the approach.

Saying no to a customer is a relationship skill: protect them from a bad outcome while keeping their trust. Interviewers want the reason, the alternative, and the framing. Here is the move.

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

The most common opener in an Applied AI loop, and the one candidates most often answer with a taxonomy lecture. The interviewer is screening for two things in ninety seconds, and neither of them is your definition of MLOps.