Databricks AI Engineer interview questions

Complex tasks rarely fit one prompt, and free-text LLM output rarely drops into code cleanly. What matters is decomposing into chained steps and parsing each output. Here is the answer that ties prompting to real pipelines.

'Eval is the new system design' for LLM apps, and starting with zero data is the real test. What shows depth is bootstrapping a golden set, choosing task-specific metrics, and running evals continuously as a regression gate.

This is an architecture and business decision, not a religious one. What shows depth is weighing capability, cost, privacy, control, and operational burden, then committing to a call instead of declaring 'open is always better.'

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

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

The per-token sticker price masks the real decision. Self-hosting only pays off past a volume break-even most teams misjudge. Here is the back-of-envelope a staff engineer does on the whiteboard.

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

The same model can land 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.

In naive LLM serving most GPU memory bleeds away to KV-cache fragmentation. PagedAttention adapts virtual memory paging to win it back. What matters is explaining the fragmentation problem and how blocks resolve it.

MoE trims compute but is awkward to serve: experts have to be sharded, tokens routed across devices, and batches balanced. What matters is the all-to-all communication and the load-imbalance problem, not the training story.

Grammar-constrained decoding seems like a solved problem until tokenization stops lining up with the grammar. The signal is the token-vs-character boundary mismatch and how prefix automata and token healing address it.

Temperature 0 is not the same as deterministic, and the reason lives in the GPU kernels, not the sampler. What gets scored is naming the batch-invariance problem and knowing which fixes are real versus placebo.

Everyone can name learning rate and epochs. The signal is knowing that LoRA wants a learning rate roughly 10x higher than full fine-tuning, why alpha/r is the only scaling that matters, and which curve tells you your rank is too big.

Most teams reach for a token-dropping compressor and pay an accuracy tax for tokens they could have had for almost nothing. The ranking of levers matters more than any single technique, and the top of the list is not compression at all.

A paraphrased prompt comes back with a training answer, verbatim. This is small-dataset SFT overfitting, not the pretraining memorization problem people confuse it with, and the fix has a strict order of operations.

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

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

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

The whiteboard question that spans the entire stack, from BPE to the sampler. What separates a strong answer is knowing that prefill and decode stress opposite hardware resources, and that nearly every serving decision you will ever make falls out of that one fact.

Definitions take thirty seconds. The interview is about the four things log-probs buy you in production: a confidence signal, banning tokens, guaranteeing valid output, and classification you can calibrate. Plus the tokenization gotcha that quietly breaks all of them.

Both work, so the decision is made by four numbers: how many examples you have, how far the capability has to move, how many variants you must serve, and how many GPUs you own. The serving axis is the one candidates never mention.

The follow-up every interviewer holds in reserve after you say you fine-tuned something. A task-metric win proves almost nothing on its own. Here is the five-part protocol that separates a shipped model from a demo.

Merging one adapter is a single matrix add. Merging four is where careers get interesting: the low-rank updates were each trained as if the others did not exist, and they collide. Here is what actually works and when to route instead.

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

Most staleness complaints are not model problems, and the engineer who says so first wins the round. Here is which changes belong in the index, which belong in the weights, and the lifecycle machinery that keeps months of refreshes from eroding the model.

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

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

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

Every request pays for the prompt and almost nobody has looked at where the tokens actually go. It is rarely the part you can read: thirty tool schemas and seven stale examples usually outweigh the system prompt, and the output side costs several times more per token.

One of the most common AI, ML, and GenAI design rounds. Sketching embed-retrieve-generate is easy; the signal lives in chunking, hybrid retrieval, the rerank/latency tradeoff, and how you prove it works. Here is the structure that scores.

The two knobs that decide whether a RAG system works, and the two candidates tend to gloss over. The signal is tuning chunking against recall and knowing precisely what dense retrieval drops that BM25 recovers. Here is the reasoning, not the rules of thumb.

Most RAG systems ship without genuine evaluation, which is why most of them quietly degrade. The signal is breaking evaluation into retrieval and generation, and scoring faithfulness apart from relevance. Here is the framework that makes RAG improvements measurable.

Enterprise RAG breaks on isolation, not on retrieval quality. The signal is enforcing tenant and document-level permissions server-side, at retrieval time, so the model can never surface data a user is not allowed to see. Here is the design that survives a security review.

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

Retrieval quality is bounded by the query, and raw user queries are frequently poor for search. The signal is knowing the techniques that rewrite the query ahead of retrieval and which failure each one fixes.

Vector RAG quietly breaks on two query shapes: multi-hop chains and global 'what are the themes' questions. The signal is knowing precisely what the graph gives you and the construction cost it demands.

Chunking quietly caps 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 separates retrieval size from context size.

Real corpora contradict themselves (old versus new policy, different teams), and naive RAG quietly picks one or fuses them into a wrong answer. The signal is spotting conflict and resolving it through recency, authority, and transparency.

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

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

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

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

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

Pushing every query through one pipeline wastes 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 stop a misroute from sinking the answer.

Small chunks match precisely but starve the LLM of context; big chunks carry context but match badly. Parent-child retrieval declines to choose. The signal is separating what you match on from what you feed the model.

Fixed-size chunking cuts 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.

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

At a billion vectors the index choice is a memory budget question before it's a recall question. Flat search is off the table, HNSW may not fit, and PQ swaps recall for RAM. Here is the call a staff engineer makes on the whiteboard.

When the right answer isn't even in the top-50, the generator can't rescue you. Low recall has a short list of usual suspects. Here is the order to check them so you fix the cause, not a symptom.

A 90% eval score alongside angry users means your eval set doesn't resemble reality. The fix is to make evaluation follow production, not the reverse. Here is how.

Late interaction keeps one vector per token, so a corpus that fit in a few GB as single vectors can swell 100x. Interviewers want to see you know the compression and indexing tricks (centroids, residuals, PLAID) that make multi-vector retrieval shippable.

Vector search over rows is the wrong tool when the user asks for a count or an aggregate. Interviewers want to see you retrieve the right schema, generate validated SQL, and know when to query the database instead of embedding it.

Re-embedding 10M documents nightly is wasteful when only 0.5% changed. Interviewers want to see you upsert by stable id, handle deletes and tombstones in an ANN index, and compact before fragmentation tanks recall and latency.

An answer can be correct yet still unfaithful, asserting 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.

Pushing top-k higher raises recall but buries the answer in noise, and a tight reranker raises precision but can discard 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.

An off-the-shelf cross-encoder is general; your domain carries jargon and relevance rules it never encountered. The signal is knowing when fine-tuning pays off, how to mine hard negatives, and how to avoid training a reranker that merely memorizes your retriever's mistakes.

A better embedding model is worthless if old and new vectors share an index, because their spaces are incompatible. The signal is the dual-index re-embed-then-cutover plan, the cost math, and how to prove the new model is actually better before you flip.

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 shrink the bill.

A 0.91 cosine score and a useless passage are not a contradiction. The candidates who score here name the encoding mismatch, the topical-but-not-answering chunk, and why an absolute score cutoff was never going to work.

Every RAG design says 'just filter by tenant_id.' Almost nobody can explain why that one line can quietly cut recall in half. The answer is in what the filter does to the ANN graph.

Six stages, six isolating experiments, six metrics. The candidates who score do not guess at knobs, they bisect the pipeline, and they instrument the rungs nobody else does: ranking, context assembly, generation.

Freshness and reproducibility pull in opposite directions, and almost every team builds only for freshness. A pointer into a mutable index is not a record. Here is what an auditable knowledge base actually requires.

float32 is far more precision than ranking needs. int8 is close to free, binary is 32x smaller, and the difference between a working binary index and a recall disaster is one word: rescoring.

An hour-long agent run is a distributed workflow wearing an LLM hat. The signal is designing serializable state with step-level checkpoints, and knowing why resume is easy while replaying a side effect is not.

Tool calling costs one LLM round trip per action. Code costs one round trip for a loop over 500 records. The signal is knowing exactly what you trade away when you let the model write the program instead of the call.

Interviewers ask about these by name and listen for whether you have read the source or only the README. The signal is explaining the runnable interface, why an agent needs a cyclic graph rather than a chain, and what the layers hide.

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

Labs reach for this practical screen often, since it probes concurrency, time handling, and judgment inside 20 lines. The pitfall is a background thread that burns CPU. Below is the lazy-refill approach interviewers expect, along with the follow-ups.

A recurring ML-coding screen. The loop itself is easy; what interviewers watch for is k-means++ init, a genuine convergence criterion, and awareness of the failure modes. Here is the compact implementation plus the follow-ups interviewers reliably ask.

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

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

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

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

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

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

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

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

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

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

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

Plain multi-head attention is rarely the whole exercise: the usual extension is to chain it into KV-cached decoding and GQA in one sitting. The locked answer walks the NumPy implementation, the equivalence check that proves your cache is correct, and the reshape bugs that silently corrupt attention.

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

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

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

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

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

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

The classic recursive-descent exercise with an applied-AI twist: the JSON your model streams stays truncated mid-token for the whole generation. What matters is a clean strict parser plus a small repair layer, not a second parser. The code follows.

The most job-shaped coding screen in AI, ML, and GenAI engineering: fan out N LLM calls without melting the rate limit or losing the batch to one bad request. What matters is the retry policy, not the async syntax. Below is the version that passes.

The most-asked hands-on LLM exercise: a chat history that outgrows the context window. What gets scored is not the sliding window, it is the region eviction is never allowed to touch. Below is the version that passes.

Every RAG system packs a prompt, and the packing bug is always the same one: the input fits the window exactly, so the model has nowhere left to answer. The arithmetic here is what separates a candidate who has shipped from one who has read about it.

The lookup is three lines of linear algebra. What separates a cache from an incident is where the similarity threshold came from, and the one-token queries ('2023' vs '2024', 'not') that no threshold can catch because the embedding barely moves.

Asking a model which answer is better is one line of code. Getting a number you would let block a deploy takes position-bias control, a confidence interval, and a human-labeled set the judge is measured against. Here is the harness.

Every agent is a loop around this function. The candidates who fail it raise an exception on a bad tool call; the ones who pass hand the error back to the model as a tool result and let it fix itself on the next turn.

Every RAG system starts here, and most candidates ship the same bug: they size the chunk in characters and call it tokens. Below is running code for all four strategies, plus the infinite loop in the overlap arithmetic and the one in the recursion.

This code runs on every single response, so it sits on the critical path and a heavyweight check here doubles your p95. The signal is in the ordering, the fail-open decision when the guardrail times out, and the fact that you cannot un-send a token you already streamed.

Anyone can call a rerank endpoint. The word doing the work in this question is 'prove': you have to implement DCG, ideal DCG, and nDCG@k from graded labels and report the before-and-after. Plus the ceiling nobody mentions until it bites them in production.

Asking a model 'is this answer hallucinated?' barely beats a coin flip. This is the build: claim extraction, a judge forbidden from using world knowledge, a denominator that excludes hedges, and one model call per claim, which decides where the check can run at all.

A prompt is code, but most teams edit it in a dashboard with no history and then cannot explain last Tuesday's quality drop. This is the small piece of infrastructure that makes prompts reviewable, pinnable, and instantly reversible.

Most RAG projects do not die at the retriever, they die at ingestion. Naive PDF extraction interleaves columns into nonsense, shreds tables, and stamps the footer into all 4,000 chunks. Here is the parser that survives real documents.

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

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

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

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

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

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

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

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

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

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

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

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

Accuracy against a held-out label is the wrong instrument for a system with no single right answer, an open failure space, and a metric that is itself a model. Here is what breaks, what survives, and what replaces it.

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

SCD2 tells apart engineers who have actually run pipelines from those who have only read about them. The answer rests on a single atomic MERGE that closes the prior row while opening the new one, and holds up when the job retries.

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

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

The Databricks-flavored performance question. What interviewers want is a candidate who heads straight for the usual suspects (skew, shuffle, spill) through the Spark UI rather than guessing. Here is the diagnostic order and the fixes that genuinely move the needle.

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

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

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

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

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

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

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

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

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

Hierarchies (org charts, bill-of-materials, category trees) call for recursion, and a self-join reaches only one level down. The signal is the recursive CTE with its anchor plus recursive members, and understanding how it terminates.

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

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

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

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

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

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

A LATERAL join lets a FROM-clause subquery reference columns from the table ahead of it, which a normal join cannot. The signal is spotting the per-row use cases: top-N per group, table functions, unnesting arrays.

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

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

MERGE does insert, update, or delete in a single statement, the foundation of incremental loads and slowly-changing dimensions. The signal is the matched/not-matched logic and what keeps a retry safe.

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

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

A dedicated vector database is not always required. When embeddings sit beside your relational data, nearest-neighbor in SQL makes filters and joins easy. Here is how, and the scale where it breaks down.

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

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

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

The applied data-wrangling screen: here is a grubby database, turn out 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 rather than trusting it.

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

Wide tables with a column per period are easy to read and hard 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.

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

The reflex is 'add an index,' but a good engineer reads the plan before touching anything. The signal is spotting the operator that dominates runtime, comparing estimated against actual rows, and knowing the seq-scan, bad-join, and spill patterns.

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

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

Each of the three brings ACID to object storage, yet they were built to solve different problems. The signal is fitting the format to the workload (engine neutrality, Spark-native ACID, or streaming upserts) instead of naming a favorite.

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

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

Overlapping subscription or session windows have to collapse into clean periods, and a naive self-join runs quadratic. The signal is the gaps-and-islands trick: a running max end-time that marks where each new island begins.

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

A backfill that double-counts or knocks over the live pipeline is worse than the bug it fixes. The signal is idempotent partition-scoped rewrites, keeping backfill compute isolated from live runs, and validating before the swap.

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

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

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

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

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

The moment a company runs LLMs in more than one place, it needs a gateway. The signal is the cross-cutting concerns (cost, reliability, observability, governance) that a gateway consolidates, not merely 'proxy the API.' Here is the design.

Anomaly detection seems simple until seasonality, cold start, and alert fatigue arrive. The signal is modeling the expected baseline (including weekly and daily cycles), picking unsupervised methods when labels are scarce, and tuning so you do not bury users in false alarms. Here is the design.

Limited GPUs, dozens of models, and every team demanding low latency for little money. The signal is whether you can shape that into a single governed serving fleet: continuous batching, KV cache, per-tenant quotas, and cost you can genuinely attribute.

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

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

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

Exact-match caching does little when no two prompts match. Semantic caching reuses answers across similar queries, and its entire danger is handing back a near-match that is subtly wrong. Here is how to build it safely.

Batch scoring a billion items is a throughput-and-cost problem, the reverse of low-latency serving. Every choice that harms latency works in your favor here. Here is how to design for dollars-per-million-documents.

When every team evaluates prompts in one-off notebooks, an org ships regressions and argues about vibes. A shared eval platform turns quality into something measurable and comparable. Here is what it must provide.

When prompts live inside source code, every wording tweak becomes a full deploy and nobody knows which prompt is running. The fix is to treat prompts as managed, versioned configuration. Here is the platform.

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

Hand every team an LLM API key and your bill turns into a mystery capped by a six-figure surprise at month end. Attributing, capping, and optimizing spend is a platform feature. Here is how to build it.

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

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

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

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

Selling RAG as a product means wrangling messy ingestion, multi-tenant isolation, and per-customer index freshness, all behind a simple API. See the ingestion and query planes, how to keep tenants isolated, and how to hand customers eval and observability.

Metrics, traces, and IoT data are append-heavy, time-ordered, and seldom updated. A general database handles this poorly. The wins come from columnar layout, compression tuned for timestamps, downsampling, and retention. Here is the time-series design interviewers want.

Raw clickstream lands in object storage and somehow turns into clean tables, dashboards, and ML features. The design questions are table format, the bronze-silver-gold layering, batch versus streaming, and how you handle schema drift and late data. Here is the lakehouse blueprint.

Moving a cloud-API POC into a bank or defense network kills your model provider, your judge API, and your vendor dashboards in one stroke. Learn the signed-bundle supply chain, local evaluation loop, and zero-egress observability that make an air-gapped LLM stack actually operable.

Five thousand businesses, five thousand assistants, one platform. The hard parts are tenant isolation you can defend, noisy neighbors, onboarding a tenant with zero data, and evaluating assistants you can never manually QA. Here is the control plane and the data plane.

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

A provider outage should cost you quality, not the feature. The answer that scores is a pre-decided fallback ladder, a timeout policy that treats slow as down, and the discipline to test the path you hope never runs.

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

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

The trap is leaping straight to 'add more GPUs.' The signal is profiling first, then reaching for the cheap, no-retrain levers in the correct sequence. Here is the diagnose-then-optimize playbook for p99.

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

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

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

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

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

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

You cannot improve an LLM app you cannot see into, and LLM observability is not service monitoring. What counts 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. What counts is telling prompt (prefix) caching apart from semantic caching and knowing when each is safe.

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

Routing each request to the right model is one of the biggest LLM cost/latency levers in production. What counts 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. What counts is the actual statistical methods and separating data drift you can detect without labels from concept drift you often cannot.

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

When a model regresses or an auditor asks 'how was this built,' guessing is a failing answer. What matters is tracking the entire chain so any model can be reproduced and any past decision explained. Here is the chain.

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

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

AI systems get expensive fast, and 'the GPU bill is huge' means nothing you can act on without attribution. What matters 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. What matters is knowing outputs run in parallel then get discarded, and how it complements canary and A/B. Here is the answer.

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

An ML platform is the internal system that lets many teams build and ship models reliably. What matters is naming the components (data, features, training, registry, serving, monitoring) and arguing why standardizing beats per-team reinvention, plus when not to build.

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. What matters is the ongoing-competition framing and disciplined, pre-committed promotion.

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

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

'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 already have a rollback and compliance problem. Here is the promotion pipeline.

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

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

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

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

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

'Works on my machine' is a dependency and environment problem, and for ML it drags in CUDA versions and exact library pins that shift numerical results. Here is how to bring the production environment in line with training.

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

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

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

You cannot put a 2 TB dataset in git, and copying it per experiment bankrupts you. What matters 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. What matters 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.

A platform that no one uses is wasted headcount; a platform built too early is premature. What matters is justifying the investment by leverage and designing a paved path teams adopt willingly. Here is the framing.

Four drift tests, four different assumptions. The weak answer lists them; the strong one knows which handles high-dimensional embeddings, which requires binning, and which returns a calibrated p-value. Here is how to choose.

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

Retrain too often and you burn money and risk regressions; too rarely and the model rots. The strong answer is a layered trigger policy with guardrails, not one cron job. Here is how to set the cadence.

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

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

A provider swap does not fail with a 500. It fails by staying up and quietly getting worse. The signal is knowing what actually changes under you on a model swap, and the shadow-plus-staged-ramp protocol that catches it before your users do.

Your eval set is clean, well-punctuated, and phrased the way you think about the problem. Your users are not. The move that turns this from a vibe check into an engineering artifact is measuring invariance rather than accuracy, and gating on the number it produces.

Knowing the algorithms is only half the job. The rest is the serving stack that actually delivers throughput within a latency budget. What they grade is whether you match the server to the workload and name the four knobs that move the needle.

Picking GPUs is a genuine 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 nothing like 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 has to 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.

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

LLM inference has two phases with opposite resource profiles, and co-locating them lets a long prompt stall everyone else's tokens. The signal is knowing why prefill and decode fight, and what separating them costs. Here is the answer.

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

Almost nobody builds a serving stack by hand. What interviewers watch for is whether you know what frameworks give you (batching, multi-model, GPU scheduling) and why LLM-specific servers even exist when general ones batch already.

At long context the KV cache, not the weights, dominates GPU memory and decode bandwidth. What counts is spotting it as the binding constraint and naming the levers that shrink it without wrecking quality.

A newly booted replica is sluggish on its opening requests while weights load and kernels compile, which fights with reactive autoscaling. The signal is identifying where cold start comes from plus the warmup and provisioning remedies.

Running one full fine-tuned model per customer grows GPU count linearly and drains the budget quickly. A method exists to pack hundreds of variants onto a single GPU without sacrificing batching. The interviewer wants to hear how.

CPU-based autoscaling that suits a web tier quietly breaks on GPU inference: the signal is wrong, and replicas need minutes to warm. The interviewer wants the signals you genuinely scale on and how you mask the cold start.

The counterintuitive reality of LLM serving: token generation is capped by how quickly you can read weights out of memory, not by arithmetic. Once that clicks, the entire optimization menu follows from one number.

Spot GPUs frequently run 60-90% cheaper, and they disappear with two minutes' notice. The savings hold only if a preemption costs you minutes rather than the whole run. Here is how to make that the case.

Naive 4-bit quantization can wreck quality, and the reflex to give up and serve fp16 leaves a large speedup unclaimed. The accuracy is usually recoverable. Here is the ladder of fixes.

Pinning one GPU per model leaves most of a fleet stranded on idle silicon. Sharing safely is a genuine systems problem with four distinct mechanisms, each suited to a different traffic shape. Here is how to choose.

Launching an LLM service on a guessed 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.

One long prompt can freeze every other user's token stream for hundreds of milliseconds. Chunked prefill carves that prompt up so decode keeps flowing. Here is the mechanism and the knob that controls it.

A shared system prompt is re-prefilled on every request unless the server remembers it. Prefix caching skips that work, but only when the blocks align exactly. Here is the hashing and eviction machinery underneath.

Round-robin routing throws away a feature that doubles throughput: cache locality. Designing the router means picking a replica by KV state, not just least-loaded. Here is the two-layer design.

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

GPU memory runs out well before you run out of conversations to cache. Offloading KV to CPU or NVMe buys capacity, but the interconnect can turn into the new bottleneck. Here is the bandwidth math.

FP8 serving is fast and usually fine, until it quietly degrades on the one workload your benchmark did not cover. What counts is knowing what FP8 breaks and how to validate it. Here is the recipe.

Forcing valid JSON sounds free, but the mask computation can stall every decode step. The fix is precompiling the grammar into a fast automaton. Here is where the cost hides and how to strip it out.

Most models do not fill a GPU, so one model per GPU wastes money. The three sharing mechanisms (MIG, MPS, swapping) differ widely in isolation and overhead. Here is how to pick.

When each request thinks for 30,000 tokens, serving swings from compute-bound prefill to memory-bound decode, and the KV cache turns into the resource you genuinely schedule. The levers that governed chat traffic stop being the ones that count.

Most answers optimize the training run. For any model that gets used, inference dominates lifetime energy, and the biggest carbon lever is the serving stack. Measure first, then cut the thing that is actually large.

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

Raw tokens per second is gameable: crank the batch size and the dashboard looks great while every request misses its latency target. Goodput is the throughput that actually meets your SLOs, and it is the number you size and autoscale on.

An image is not one input, it is a large prompt. Once you internalize that image tokens dominate prefill, the cost levers stop being model choices and start being resolution, tiling, and cache placement.

A CISO-facing question that trips up engineers who focus only on model quality. What matters is treating governance as architecture rather than a checkbox: minimization, isolation, auditability, and never training on customer data by default. Here is the framework.

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

AI features create cross-tenant leak paths that classic SaaS isolation never had to reckon with: shared embeddings, shared caches, and fine-tunes that memorize. One leak ends an enterprise contract. Here is the isolation model.

Asking the model to keep secrets or enforce permissions puts the job on the wrong component. The signal is enforcing access control before retrieval, in code you trust, and treating the LLM as untrusted compute over data that is already authorized.

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

The technique works and everybody knows it works. The interview is not testing whether you can generate the training set; it is testing whether you know what you are agreeing to when you do.

At an AI company, arguing against AI is a strong signal: it shows judgment ahead of hype. Interviewers use it to spot engineers who solve problems instead of reaching for a favorite hammer. Here is how to tell it.

Most AI pilots fail on scoping rather than the model: fuzzy success criteria, the wrong use case, or data that was never ready. For customer-facing and applied AI roles, running a pilot well is the job itself. Here is the playbook.

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

Scope creep quietly sinks deployments and erodes trust on both sides. Interviewers want to see you defend the timeline without turning into the team that says no to everything. Here is the move.

A failed prod deployment stress-tests judgment under pressure. Interviewers want to see stabilize-first instincts, clean communication, and a root-cause fix that heads off a repeat. Here is the arc.

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

Vague asks are standard in customer-facing AI work. Interviewers look for structured discovery that surfaces the real problem and a measurable first win, not a rush to build. Here is the method.

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

Rescuing a churning account is diagnosis under pressure: find the real reason, fix what you can, and win back trust with action. Interviewers look for a method, not a discount. Here is the move.

An embedded customer engagement works only if the customer can run it without you. Interviewers look for enablement and a real handoff plan, not a dependency. Here is how to build self-sufficiency.

Telling a customer no is a relationship skill: shield them from a bad outcome while keeping their trust. Interviewers look for the reason, the alternative, and the framing. Here is the move.

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

The number is bait. Interviewers use this to see whether you treat a benchmark delta as a decision or as a claim to be audited, and whether you can price latency, cost, and on-call burden against accuracy. Here is the answer that scores.

The classic closer, and most candidates answer it with a horoscope or a list of tool names. The signal is whether you hold an actual view, can justify it from what is already happening, and know what it means for the job.

Most candidates answer this with a speech about tradeoffs. The ones who get hired describe a mechanism: the teams that ship fastest in AI are not the ones with fewer guardrails, they are the ones whose guardrails make a mistake cheap.

The ordering is the answer, and one move separates the people who have shipped from the people who have prototyped: where evaluation sits in the sequence. Most candidates put it in the wrong place and lose the question in the first sentence.