Machine Learning Interview Questions: 16 Answers From Bias to Drift

Last updated: October 2026

Quick Answer

Machine learning interview questions test whether you can diagnose a model, not just name one: tell bias from variance, pick a loss, metric and threshold that match the cost of errors, explain why offline results fail in production, design an end-to-end system such as a recommender or fraud model, and keep it healthy after launch. Rehearse the conceptual and system design answers aloud in OphyAI Interview Practice, use Coding Interview for live coding rounds, and use Interview Copilot for real-time suggestions on live video rounds.

#	Question	What the interviewer is testing
1	Training and validation error are both high. What now?	Diagnosing bias versus variance
2	L1 versus L2 regularization	Why L1 produces sparse weights
3	AUC is 0.92 but the probabilities are wrong. Does it matter?	Ranking versus calibration
4	How do you train on 1:1,000 imbalanced data?	Resampling, weighting and probability correction
5	Offline AUC 0.95, production much worse. Debug it.	Training-serving skew and time leakage
6	Random forest or gradient boosting?	Bagging versus boosting trade-offs
7	Encode a categorical feature with 2 million values	Hashing, target encoding, embeddings
8	Explain attention and why it is scaled	Transformer fundamentals
9	Your training loss goes to NaN	Practical deep learning debugging
10	Design a recommender for a video app	ML system design: retrieval and ranking

This page is for machine learning engineer, applied scientist and ML-heavy software roles. If your loop leans on statistics, experiment design and product metrics, start with our data scientist interview questions, which already covers overfitting basics, data leakage definitions, churn modeling and the 98%-accuracy fraud trap. The questions below go one level deeper into training, systems and production.

What ML roles pay and how the loops are built

The US Bureau of Labor Statistics (BLS) has no separate “machine learning engineer” occupation. The closest, computer and information research scientists, earned a median of $140,300 in May 2025, with 22% projected growth from 2025 to 2035 and a master’s degree as the typical entry education. Data scientists earned a median of $120,230 in May 2025. Big-tech offers add stock; those figures are candidate-reported and vary by level and city.

What employers and reputable sources say about the loop (checked October 2026):

Source	What it says
Pinterest Careers (ML and data science new grads)	CodeSignal assessment, 30-minute recruiter screen, hiring manager review, 3-4 technical interviews with engineers, then a 30-minute call with hiring managers
Meta Careers (hiring process)	Design interviews run in CoderPad with Mermaid
Amazon applied scientist (third-party guide and candidate reports)	Reported loops mix coding, ML breadth, ML depth on your own projects, a science application or design round, and Leadership Principles in every round; Amazon has not published this breakdown
Chip Huyen, ML Interviews Book	”Almost all companies I’ve talked to” ask at least one ML systems design question

The Questions, With Sample Answers

Each answer is a template from a fictional candidate. Swap in your own projects and numbers; interviewers probe whatever you claim.

1. “Your model has high training error and high validation error. What do you do?”

Why they ask it: It tests whether you can diagnose before you tune. The opposite case (low training error, high validation error) is the classic overfitting question; this one is the less rehearsed half.

Sample answer: “Both errors high and close together means high bias: the model underfits. Expected squared error splits into bias squared, variance and irreducible noise, and here bias dominates. First I’d check the noise floor, for example human-level error or label agreement, because if labels are 15% inconsistent I can’t beat that. Then I’d look for bugs: a wrong label join or features scaled to zero. If the pipeline is clean, I’d add capacity or signal: richer features, interactions, a more flexible model such as boosted trees instead of a linear model, and less regularization. More data rarely fixes bias. I’d confirm with learning curves: if both curves plateau high and close together, extra data won’t help, but better features will.”

What weak answers look like: “Add more data” or “use dropout,” which are variance fixes, or reducing regularization without checking for a pipeline bug first.

Prepare with OphyAI: say the diagnosis tree aloud in Interview Practice’s technical format until “noise floor, bugs, capacity” comes out in order.

2. “What’s the difference between L1 and L2 regularization, and why does L1 give sparse weights?”

Why they ask it: Almost every ML breadth round touches it. The “why” separates memorization from understanding.

Sample answer: “Both add a penalty to the loss. L1 adds lambda times the sum of absolute weights; L2 adds lambda times the sum of squared weights. L2’s gradient is proportional to the weight, 2 lambda w, so it shrinks big weights hard and small weights gently, and they approach zero without reaching it. L1’s subgradient has constant magnitude lambda, so even a tiny weight gets the same push, and any weight whose data-loss gradient at zero is smaller than lambda in magnitude ends up exactly at zero. Geometrically, the L1 constraint region is a diamond whose corners sit on the axes, and the loss contours usually touch it at a corner. I use L1 when I want feature selection, L2 when features are correlated and I want stable shared weights, and elastic net when I need both.”

What weak answers look like: “L1 is for sparsity” with no mechanism, or mixing up which norm uses squares.

Prepare with OphyAI: ask Interview Practice for follow-ups after this answer; “what happens with correlated features?” is the usual next question.

3. “Your model’s AUC is 0.92, but its predicted probabilities don’t match reality. Does that matter?”

Why they ask it: It checks whether you know that ranking quality and probability quality are different properties.

Sample answer: “It depends on how the output is used. AUC only measures ranking: whether positives score above negatives. If the product just sorts items, a miscalibrated model is fine. But if anything consumes the number as a probability, it matters: an ad auction multiplying predicted click rate by bid, an expected-loss calculation, or a fixed threshold shared across segments. A well-calibrated model is one where, of the cases scored near 0.8, about 80% are positive. I’d plot a calibration curve on held-out data and check the Brier score or log loss. To fix it, I’d fit Platt scaling, a logistic fit on the scores, or isotonic regression on a separate calibration set; isotonic is more flexible but overfits on small data, so I’d use sigmoid below roughly a thousand samples.”

What weak answers look like: “AUC is high, so it’s fine,” or calibrating on the training set.

Prepare with OphyAI: practice the “depends on how the output is used” framing in Interview Practice; it signals product sense.

4. “How would you train a classifier when positives are 1 in 1,000?”

Why they ask it: Fraud, ads and abuse problems are all heavily imbalanced. This is the training-side follow-up to the metric question.

Sample answer: “First I’d confirm I have enough positives in absolute terms; 1 in 1,000 of 50 million rows is 50,000 positives, which is plenty. I’d evaluate with precision-recall metrics at an operating point, not accuracy. For training I’d try class weights in the loss first, since that keeps all data. If training cost is the issue, I’d downsample negatives, keeping a fraction r of them, and upweight the kept negatives by 1/r so the loss reflects the true distribution. If I downsample without weights, the model’s odds are inflated by 1/r, so I’d correct: p = r p’ / (r p’ + 1 - p’). I’d treat the resampling ratio as a hyperparameter, and avoid synthetic oversampling like SMOTE on high-dimensional or tabular fraud data unless validation proves it helps.”

What weak answers look like: Oversampling before the train-test split (duplicates leak into validation), or never correcting probabilities after downsampling.

Prepare with OphyAI: rehearse the probability-correction formula aloud in Interview Practice; interviewers often ask you to derive it.

5. “Your model scored 0.95 AUC offline but performs much worse in production. How do you debug it?”

Why they ask it: This is the question interviewers use to find people who have shipped models. It goes beyond defining leakage.

Sample answer: “I’d separate three causes. One, training-serving skew: the feature pipelines differ. I’d log the features the model actually received at serving time and diff them against the training values for the same entities; null rates, units and default values are frequent culprits. Two, time leakage: a feature computed with data from after the prediction moment, such as a 30-day aggregate built from a nightly snapshot that already includes the outcome. I’d rebuild features with point-in-time joins and re-run the offline evaluation on a time-based split. Three, real distribution change since the training window. Then I’d check whether the production metric is even measured the same way, because delayed or biased labels can make a good model look bad. Going forward I’d save serving-time features and train on those.”

What weak answers look like: “Retrain on newer data” before finding the cause, or a definition of overfitting.

Prepare with OphyAI: tell one real skew or leakage story in an Interview Practice mock and get per-answer feedback on whether it sounds specific.

6. “When would you use a random forest instead of gradient boosting?”

Why they ask it: Tree ensembles still win most tabular problems. Interviewers want the mechanism, not a leaderboard opinion.

Sample answer: “A random forest trains deep trees independently on bootstrap samples with a random subset of features at each split, then averages them. The randomness decorrelates the trees’ errors, so averaging mainly reduces variance. Gradient boosting builds shallow trees sequentially, each one fitted to the negative gradient of the loss given the current ensemble, so it mainly reduces bias. In practice boosting usually wins on accuracy for tabular data but needs tuning: learning rate, number of trees with early stopping, depth, and it is more sensitive to label noise. A random forest is a strong default with little tuning, parallelizes trivially and gives a free out-of-bag estimate. I’d start with a forest as a baseline, then try histogram-based boosting, which is much faster on large data and handles missing values natively.”

What weak answers look like: “XGBoost is always better,” or saying boosting trains trees in parallel.

Prepare with OphyAI: practice explaining both in 60 seconds in Interview Practice, then let it push on hyperparameters.

7. “How would you encode a categorical feature with 2 million distinct values, like merchant ID?”

Why they ask it: Feature engineering on high-cardinality IDs is everyday work in ads, payments and recommendations, and the leakage traps are subtle.

Sample answer: “One-hot is out: 2 million sparse columns and most merchants have few examples. I’d consider three options. Feature hashing into, say, 2^20 buckets: fixed memory, handles unseen merchants, accepts some collisions. Target encoding: replace each merchant with its smoothed historical positive rate, shrunk toward the global rate when counts are small. The trap is leakage, so I’d compute it out of fold, each row encoded with statistics from other folds, and in production from data strictly before the event. Third, learned embeddings in a neural model, which also share information between similar merchants. I’d add count features, like transactions in the last 7 days, and a bucket for rare or new IDs, because cold start is where these features fail.”

What weak answers look like: One-hot encoding everything, or target encoding computed on the full dataset including the row being predicted.

Prepare with OphyAI: Interview Practice can play the skeptical interviewer; practice defending how you prevent target-encoding leakage.

8. “Explain how attention works in a transformer. Why is it scaled?”

Why they ask it: Transformers now appear in ML breadth rounds even for non-NLP roles. Interviewers check whether you understand the formula, not just the buzzwords.

Sample answer: “Each token is projected into a query, a key and a value. Attention scores are dot products of a token’s query with every key, and the output is softmax(QK^T / sqrt(d_k)) V: a weighted average of values, weighted by how well each key matches the query. The scaling matters because if query and key components have unit variance, their dot product has variance d_k, so large dimensions push the softmax into saturated regions with tiny gradients; dividing by sqrt(d_k) keeps the scale stable. Multi-head attention runs several of these in parallel on lower-dimensional projections, eight heads in the original base model, so different heads can attend to different patterns. Since attention ignores order, positional encodings are added. The cost is quadratic in sequence length, which drives most long-context engineering.”

What weak answers look like: “Attention lets the model focus on important words” with no formula, or no idea why positional information is needed.

Prepare with OphyAI: whiteboard the formula, then explain it aloud to Interview Practice as if mentoring a junior engineer.

9. “Your neural network’s training loss suddenly becomes NaN. Walk me through debugging it.”

Why they ask it: It tests hands-on training experience. People who have trained models answer with a checklist; people who haven’t answer with theory.

Sample answer: “I’d find the first step where it happens and check in order. Data: any NaN or infinite inputs, or a bad batch, so I’d assert on inputs and labels. Numerics: log of zero or division by zero in a custom loss, so I’d use the framework’s fused, numerically stable loss, such as cross-entropy on logits instead of softmax then log. Optimization: exploding gradients, so I’d log the gradient norm per step, lower the learning rate, add warmup and gradient clipping. Mixed precision: fp16 overflow, so I’d confirm loss scaling is on or switch to bf16. Then I’d try to overfit a single small batch; if the model can’t drive that loss near zero, there is a bug in the model or labels rather than a tuning problem.”

What weak answers look like: “Lower the learning rate” as the only idea, or no way to locate the step where it breaks.

Prepare with OphyAI: rehearse your debugging order in Interview Practice and ask for a follow-up on gradient clipping.

10. “When would you fine-tune a language model instead of using retrieval or better prompting?”

Why they ask it: Applied LLM work now shows up in many ML loops. The interviewer wants cost-aware judgment, not enthusiasm.

Sample answer: “I’d escalate in order of cost. First, prompting with a few good examples and a clear output format, plus an evaluation set of a few hundred labeled cases so I can measure anything. If failures come from missing or changing knowledge, like product docs or policies, I’d add retrieval, because updating an index is cheaper and more auditable than retraining, and it lets me cite sources. I’d fine-tune when the problem is behavior rather than knowledge: a consistent format or tone, a narrow classification task at high volume where a smaller tuned model is cheaper and faster, or domain language the base model handles poorly. Parameter-efficient methods like LoRA keep that affordable. Whatever I choose, the eval set decides, and I’d keep tracking it after launch.”

What weak answers look like: “Fine-tune, because it’s more accurate,” with no evaluation set or cost argument.

Prepare with OphyAI: Interview Practice’s system design format works well for practicing this escalation order out loud.

11. “Design a recommendation system for a short-video app.”

Why they ask it: The most common ML system design prompt. It tests scoping, architecture, metrics and trade-offs in 45 minutes.

Sample answer: “I’d clarify the goal first: long-term satisfaction, approximated by watch time plus explicit signals like shares and ‘not interested,’ not raw clicks. Then a funnel. Candidate generation narrows millions of videos to about a thousand using several sources: a two-tower embedding model with approximate nearest neighbor search, followed creators and trending items. A ranking model, perhaps a multi-task network predicting watch completion, like and skip, scores those candidates with rich user, video and context features. A re-ranking layer adds diversity, freshness and policy filters. For cold start, new videos get exploration traffic and content embeddings. Offline I’d measure recall at k for retrieval and AUC per task for ranking; online, an A/B test on watch time with guardrails on retention and reports. And I’d watch for feedback loops that over-promote already popular content.”

What weak answers look like: Jumping to a model before the objective, a single model scoring every video in the catalog, or no online evaluation.

Prepare for ML system design with OphyAI: run a timed system design mock in Interview Practice and check that you reach evaluation before time runs out.

12. “Design a real-time fraud detection model for card payments.”

Why they ask it: Fraud adds constraints recommenders don’t have: strict latency, delayed labels, adversaries and asymmetric costs.

Sample answer: “Requirements first: decide within the authorization path, say under 100 milliseconds, with actions of approve, step-up verification or decline. Labels arrive late, since chargebacks can take weeks, so training data lags and recent fraud patterns are underrepresented. Features: velocity counts from a streaming feature store, like transactions per card in the last hour, device and merchant risk, and distance from usual locations, all computed identically online and offline. Model: gradient boosted trees for latency and tabular strength, with rules alongside for known patterns. Thresholds come from costs: fraud loss versus false declines and review capacity. Because blocked transactions never get labels, I’d keep a small randomized holdout to measure true performance. Fraudsters adapt, so I’d monitor score distributions daily and retrain on a schedule.”

What weak answers look like: Ignoring latency or label delay, or evaluating only on accuracy.

Prepare with OphyAI: practice the requirements-first opening in Interview Practice; interviewers grade the first five minutes heavily.

13. “How do you monitor a model after deployment and detect drift?”

Why they ask it: Most model failures happen after launch. This tests MLOps maturity.

Sample answer: “I monitor four layers. System health: latency, errors, throughput. Data quality: schema, null rates and ranges for every feature, compared with training, because a broken upstream pipeline is the most common failure. Drift: input distributions and the prediction distribution, using population stability index or KL divergence on key features with alert thresholds, which catches covariate shift before labels arrive. Performance: once labels land, the actual business metric and model metric by segment. Drift alone doesn’t mean retraining, since a shift in an unimportant feature may not hurt. I’d investigate, then retrain on a schedule or on triggers, and ship the new model through shadow mode or a canary. Concept drift, where the relationship between features and labels changes, only shows in labeled performance, so label latency defines how quickly I can catch it.”

What weak answers look like: “Retrain every week” with no monitoring, or treating every drift alert as a reason to retrain.

Prepare with OphyAI: rehearse the four layers in Interview Practice until each comes with a concrete metric.

14. “Your new ranking model beats production offline. How do you decide whether to launch it?”

Why they ask it: Offline gains often vanish online. This checks whether you can run a model experiment, not just a feature test.

Sample answer: “Offline wins are a hypothesis. I’d first sanity-check the gain on recent data and key segments, and confirm latency and cost fit the serving budget. Then shadow mode: score live traffic without acting on it, to catch skew and errors. Then an online A/B test randomized by user, with the primary metric agreed before launch, such as watch time per user, guardrails on latency, complaints and revenue, and a duration set by a power calculation. For ranking, interleaving both models’ results within one list is a more sensitive early filter that needs far less traffic, but I’d still confirm with an A/B test. If it wins, I’d keep a small long-term holdout, because ranking changes shift user behavior and the content supply over time.”

What weak answers look like: “It’s better offline, ship it,” or no guardrail metrics.

Prepare with OphyAI: Interview Practice can push on your guardrails; have one metric ready for each risk.

15. “Implement logistic regression from scratch with gradient descent.”

Why they ask it: ML coding rounds often ask for a model, not a LeetCode puzzle. It checks vectorized math and numerical care.

Sample answer: “For n examples, the mean binary cross-entropy has gradient X^T(sigmoid(Xw + b) - y) / n for the weights and the mean residual for the bias. I’d vectorize with NumPy, clip the logits so exp doesn’t overflow, and add an L2 term. Then I’d test it on separable synthetic data and compare with scikit-learn.”

import numpy as np

def sigmoid(z):
    return 1.0 / (1.0 + np.exp(-np.clip(z, -500, 500)))

def fit_logreg(X, y, lr=0.1, epochs=1000, l2=0.0):
    n, d = X.shape
    w, b = np.zeros(d), 0.0
    for _ in range(epochs):
        p = sigmoid(X @ w + b)
        err = p - y
        grad_w = X.T @ err / n + l2 * w
        grad_b = err.mean()
        w -= lr * grad_w
        b -= lr * grad_b
    return w, b

What weak answers look like: Looping over rows in Python, getting the gradient sign wrong, or regularizing the bias.

Prepare for the coding round with OphyAI: write it once without autocomplete, then explain it aloud in an Interview Practice technical mock.

16. “Tell me about a model you decided not to ship.”

Why they ask it: ML judgment includes knowing when not to use ML. Google’s Rules of ML literally begins with “Don’t be afraid to launch a product without machine learning.”

Sample answer: “(Situation) Our support team wanted a model to auto-route tickets. (Task) I owned the prototype. (Action) A fine-tuned classifier reached 91% accuracy offline, but on error analysis the 9% it missed were mostly urgent billing tickets, the most expensive kind to misroute. A keyword rule plus a dropdown on the form handled 80% of tickets with near-perfect precision. I presented both options with the cost of each error type and recommended the rules first, with the model deferred until we had cleaner labels. (Result) The rules shipped in two weeks and cut average routing time by a third. Six months later we trained a model on the cleaner labels the dropdown created, and it beat the original prototype.”

What weak answers look like: A story where ML is always the answer, or a “failure” with no lesson.

Prepare with OphyAI: build two judgment stories in Interview Practice’s behavioral format and check that each result has a number.

How to Practice These

Split preparation by round: one page of breadth notes per topic above, one project you can defend for 30 minutes of depth questions, two timed system designs, the from-scratch implementations of logistic regression and k-means, and three behavioral stories. Our system design interview guide covers the infrastructure half of ML design rounds, and Python interview questions the coding screen.

• OphyAI Interview Practice runs voice or text mock interviews in behavioral, technical, system design and case formats, with follow-up questions, a transcript and per-answer feedback, so you can rehearse depth questions and full system designs before the loop.
• OphyAI Coding Interview is the Premium product for live coding and system design rounds: screenshot the problem and get a streamed approach and code.
• OphyAI Interview Copilot gives real-time answer suggestions during live Zoom, Microsoft Teams and Google Meet interviews.

Start practicing →

Frequently Asked Questions

What are the most common machine learning interview questions?

The most common are bias versus variance, regularization, evaluation metrics for imbalanced data, tree ensembles, feature engineering, data leakage and training-serving skew, transformer and attention basics, an ML system design such as a recommender or fraud model, deployment and monitoring, and a behavioral question about a model that failed or was not shipped.

How is a machine learning engineer interview different from a data scientist interview?

Machine learning engineer loops weigh coding, ML system design and production topics such as serving, latency and monitoring. Data scientist loops weigh statistics, experiment design, SQL and product metrics. Both ask modeling questions. Our data scientist interview questions cover the statistics and experimentation side.

Do I need to know deep learning for an ML interview?

For most ML engineer and applied scientist roles, yes, at the level of backpropagation, common architectures, attention, optimization and training debugging. Tabular-heavy roles in fraud, credit or ads may focus on tree ensembles instead. Read the job description: if it names LLMs, computer vision or speech, expect depth questions in that area.

What is an ML system design interview?

It is an open-ended round where you design a machine learning product end to end: clarify the objective, choose labels and features, sketch data pipelines, pick models, define offline and online evaluation, and plan deployment and monitoring. Chip Huyen’s ML Interviews Book says almost every company she talked to asks at least one such question.

How much do machine learning engineers make in the US?

BLS does not track machine learning engineers separately. Computer and information research scientists, the closest category, earned a median of $140,300 in May 2025, and data scientists $120,230. Large tech companies add stock, but those figures are candidate-reported and vary widely by level and location.

Will I have to code in a machine learning interview?

Usually. Most loops include at least one standard coding round, and many add an ML coding round: implementing logistic regression, k-means or a training loop, or manipulating data in NumPy or pandas. Pinterest’s published ML and data science new grad path starts with a CodeSignal assessment before technical interviews.

How does OphyAI work in a machine learning interview?

Rehearse the conceptual and ML system design answers aloud in Interview Practice, which asks follow-up questions and returns per-answer feedback. On live Zoom, Microsoft Teams or Google Meet rounds, Interview Copilot gives real-time answer suggestions. For live coding, Coding Interview (Coding Copilot in the desktop app, Premium plan) shows the approach, code, a dry run and the Big O.

Related Guides

Company guides where machine learning interviews show up:

• Google interview guide
• Meta interview guide
• Amazon interview guide and Amazon Leadership Principles interview guide
• NVIDIA interview guide
• OpenAI interview guide and Anthropic interview guide
• Netflix interview guide
• Pinterest interview guide and Pinterest system design interview
• Databricks interview guide and Scale AI interview guide
• TikTok interview guide

Related question guides:

• Data scientist interview questions
• Data engineer interview questions
• Python interview questions
• System design interview guide
• Behavioral interview questions and answers

Sources and verification notes

Sources checked October 2026. Questions and sample answers are original templates, not published by any employer; projects and numbers in them belong to a fictional candidate. The probability-correction formula in question 4 and the logistic regression gradient in question 15 were derived by hand; the code was reviewed by hand, not run.

• US Bureau of Labor Statistics, Occupational Outlook Handbook: Computer and Information Research Scientists: May 2025 median pay, 2025-2035 projected growth, typical education and the machine learning mention in duties (page modified August 27, 2026).
• US Bureau of Labor Statistics, Occupational Outlook Handbook: Data Scientists: May 2025 median pay (page modified August 27, 2026).
• Pinterest Careers, Interview process: machine learning and data science interns and new grads: published interview steps (dated April 1, 2024).
• Meta Careers, hiring process: design interviews in CoderPad with Mermaid. The page does not describe ML-specific rounds.
• igotanoffer, Amazon applied scientist interview: third-party guide describing ML breadth, depth, coding, science application and Leadership Principles rounds; the page returned 403 to our fetch, so this was checked from search snippets only and is labelled as reported.
• Chip Huyen, Introduction to Machine Learning Interviews Book: ML systems design questions asked at almost all companies the author talked to; research versus production roles.
• Google for Developers, Rules of Machine Learning (Martin Zinkevich): Rule #1, training-serving skew causes, and saving serving-time features.
• Google Machine Learning Crash Course, Imbalanced datasets: downsampling, upweighting and treating rebalancing ratios as hyperparameters.
• Vaswani et al., Attention Is All You Need (2017): scaled dot-product attention, the reason for the 1/sqrt(d_k) scaling, 8 heads in the base model, sinusoidal positional encodings.
• scikit-learn, Ensemble methods, Probability calibration and TargetEncoder in Preprocessing data: random forest variance reduction, boosting fitted to negative gradients, histogram boosting speed and missing-value support, Platt versus isotonic calibration (isotonic needs roughly 1,000+ samples), and cross-fitted target encoding.