Katkat

practice a little every day, paws crossed ♡

Machine Learning Engineer Interview Questions

Practice 9403 coding, system design and machine learning questions from 546 companies, sorted by role, topic and interview round. Every question has step-by-step hints, a code runner that supports 8 languages and an AI mentor; members also get the full solution walkthrough.

9403
Questions
546
Companies
11
Topics
8
Languages

Showing 391–420 of 782 results

  • MicrosoftMediumMachine Learning Engineer
    Explain metrics, regularization, and ablation studies

    This question evaluates understanding of classification evaluation metrics, regularization methods, and experimental design for component-level analysis in NLP and broader Machine Learning systems, testing competencies in performance measurement, regularization trade-offs, and causal attribution of model components.

    Machine LearningTechnical Screen
  • MicrosoftMediumMachine Learning Engineer
    Find Top K Largest Elements

    This question tests the ability to efficiently find the K largest elements in an unsorted array while managing time complexity constraints through heap-based or selection-based algorithms.

    Coding & AlgorithmsTechnical ScreenArraysHeapSorting
  • MicrosoftMediumMachine Learning Engineer
    Find pairs with the minimum absolute difference

    This question evaluates array manipulation, sorting-based reasoning, and the ability to generate ordered value pairs that reflect minimum absolute differences while handling ordering and duplicates.

    Coding & AlgorithmsTechnical Screen
  • MicrosoftMediumMachine Learning Engineer
    Find the Lowest Common Ancestor in a Binary Search Tree

    This problem tests the ability to leverage the Binary Search Tree (BST) property to efficiently locate the Lowest Common Ancestor (LCA) of two nodes.

    Coding & AlgorithmsHR ScreenBSTTreesRecursion
  • MicrosoftMediumMachine Learning Engineer
    Find the Lowest Common Ancestor in a Binary Tree

    This problem tests tree traversal techniques and recursion logic to identify the deepest node that is an ancestor to two specified nodes in an arbitrary binary tree.

    Coding & AlgorithmsHR ScreenTreesRecursionDFS
  • MicrosoftMediumMachine Learning Engineer
    Handle Cross-Team Dependencies and Scope Conflicts

    This question evaluates competency in cross-team collaboration, stakeholder management, conflict resolution, prioritization, and influencing without formal authority in a Machine Learning Engineer context.

    Behavioral & LeadershipOnsite
  • MicrosoftMediumMachine Learning Engineer
    Implement K-Means and Detect Divisible Subarrays

    This question evaluates a candidate's ability to implement an iterative clustering algorithm (K-means) and to reason about subarray sums modulo k, testing competencies in numerical computation, centroid management, edge-case handling, and efficient algorithm design.

    Coding & AlgorithmsOnsite
  • MicrosoftMediumMachine Learning Engineer
    Implement SFT Sample Packing

    This problem tests your ability to efficiently pack variable-length sequences into fixed-length blocks for training, ensuring padding tokens do not influence the loss calculation.

    Coding & AlgorithmsHR ScreenNLPData PreprocessingArrays
  • MicrosoftMediumMachine Learning Engineer
    Implement cache and merge intervals

    This question tests the ability to implement a fixed-capacity Least Recently Used (LRU) cache using hash maps and doubly-linked lists, followed by a classic interval processing algorithm to merge overlapping segments.

    Coding & AlgorithmsOnsiteLRU CacheIntervalsHash Map
  • MicrosoftMediumMachine Learning Engineer
    Measure LLM Quality and Detect Hallucinations, Then Implement an Evaluation Component

    A hands-on LLM evaluation exercise on measuring model quality, comparing prompt or model versions, and detecting hallucinations against supplied context. It also asks for a small Python groundedness scorer that flags unsupported sentences and aggregates a hallucination rate, testing evaluation judgment and clean, well-tested code.

    Machine LearningOnsite
  • MicrosoftMediumMachine Learning Engineer
    Return the k most frequent values in an array with a deterministic tie rule

    Return the k values that occur most often in an integer array, ranked by frequency with ties broken by the smaller value. It tests frequency counting, selecting the top k efficiently and producing a deterministic order when several values tie at the cutoff.

    Coding & AlgorithmsTechnical Screen
  • Mistral AIMediumMachine Learning Engineer
    Answer an LLM Systems Quick-Fire Interview

    This question tests your breadth of knowledge across the LLM stack, specifically focusing on inference optimization, evaluation strategies, and operational trade-offs.

    Machine LearningOnsiteLLMInferenceOptimization
  • Mistral AIMediumMachine Learning Engineer
    Build a Small Agent or RAG Tool with the Mistral API

    Design an end-to-end Retrieval-Augmented Generation (RAG) agent using the Mistral API to answer technical queries over internal developer documentation. The question evaluates chunking strategies, dense retrieval, prompt orchestration, latency optimizations, and evaluation methodologies.

    ML System DesignTechnical Screenragml-system-designllm-agents
  • Mistral AIHardMachine Learning Engineer
    Explain Transformer Internals and Implement Top-p Decoding

    Assess understanding of causal transformer decoding mechanics, including attention and KV caching, paired with an implementation of nucleus (top-p) sampling with temperature scaling.

    Machine LearningTechnical ScreenTransformersSampling AlgorithmsLLM Inference
  • Mistral AIMediumMachine Learning Engineer
    Optimize Nearest-Center Assignment Without Materializing NxKxD Distances

    This problem tests the ability to optimize memory usage in distance computations by leveraging algebraic expansion to avoid creating an intermediate (N, K, D) tensor.

    Machine LearningOnsiteNumPyVectorizationLinear Algebra
  • MolocoadsMediumMachine Learning Engineer
    Compute the Longest Run of Ones Across Multiple Machines

    This problem tests the ability to design a distributed data reduction pattern where partial results can be combined using associative operators to compute a global property.

    System DesignOnsiteDistributed SystemsAlgorithmsMapReduce
  • MolocoadsMediumMachine Learning Engineer
    Find the Longest Consecutive Run of Ones

    Implement an algorithm to find the maximum length of contiguous ones in a binary array without any bit flips, returning 0 for an empty input.

    Coding & AlgorithmsOnsitearraystwo-pointerssliding-window
  • NVIDIAHardMachine Learning Engineer
    Discuss Transformer LLM Design

    Discuss Transformer LLM Design evaluates ML product requirements, data/labeling, modeling, serving architecture, evaluation, monitoring, and trade-offs in a realistic interview setting. A strong answer states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    ML System DesignTechnical Screen
  • NVIDIAMediumMachine Learning Engineer
    Explain bias-variance, calibration, and model drift

    This question tests your conceptual understanding of model performance degradation over time, the significance of calibrated outputs for decision-making, and the fundamental trade-off between bias and variance.

    Machine LearningTechnical ScreenModel EvaluationProduction MLBias-Variance
  • NetflixMediumMachine Learning Engineer
    Compare Losses and Explain LoRA

    This question evaluates understanding of loss functions (mean squared error versus cross-entropy) and parameter-efficient fine-tuning via Low-Rank Adaptation (LoRA), emphasizing probabilistic interpretations, optimization behavior, and low-rank parameterization.

    Machine LearningTechnical Screen
  • NetflixEasyMachine Learning Engineer
    Design an ML Platform Portal

    This question assesses the ability to design an internal ML Platform Portal that streamlines the model lifecycle, focusing on experiment tracking, model registry, and workflow automation.

    ML System DesignOnsiteMLOpsSystem DesignScalability
  • NetflixMediumMachine Learning Engineer
    Explain self-attention, LoRA, Adam vs SGD, ViT

    This question evaluates understanding of modern Machine Learning/Deep Learning topics, including self-attention mechanics (queries, keys, values and scaled logits), Low-Rank Adaptation (LoRA) for parameter-efficient fine-tuning and memory savings, optimizer behavior (Adam versus SGD with momentum), and architectural trade-offs between Vision Transformers and CNNs including patch-size considerations. It is categorized under Machine Learning and is commonly asked because it probes both conceptual understanding and practical application—testing reasoning about training dynamics, model scaling, fine-tuning strategies, and resource/performance trade-offs.

    Machine LearningTechnical Screen
  • NetflixMediumMachine Learning Engineer
    Explain tokenization and Transformer variants

    This question evaluates understanding of tokenization techniques and Transformer architecture, covering competencies in subword and SentencePiece-style tokenizers, Transformer block internals, and comparisons of modern architectural variants and trade-offs.

    Machine LearningTechnical Screen
  • NetflixEasyMachine Learning Engineer
    How would you support ML stakeholders?

    This question evaluates skills in ML infrastructure, stakeholder management, production monitoring, model iteration optimization, and data governance when collaborating with data science partners.

    Behavioral & LeadershipOnsite
  • NetflixMediumMachine Learning Engineer
    Implement Streaming Word Counter

    This question evaluates streaming data processing, string tokenization, and frequency-aggregation competencies, focusing on maintaining accurate counts over incremental text inputs using associative data structures.

    Coding & AlgorithmsTechnical Screen
  • NetflixHardMachine Learning Engineer
    L1 vs L2 Normalization: Definitions, Geometry and When to Use Each

    A machine learning fundamentals question asking how L1 normalization differs from L2 normalization of a vector. It tests precise definitions, what each normalized vector represents geometrically, when each is the right choice, and the ability to keep normalization distinct from L1 and L2 regularization.

    Machine LearningTechnical Screen
  • NetflixEasyMachine Learning Engineer
    ML Basics Check: Bayes' Rule, Forward-Pass Arithmetic, KNN and Transformer Concepts

    A set of basic machine learning checks: a Bayes' rule posterior with a low base rate, forward-pass and parameter-count arithmetic for small neural networks, and true-or-false concept checks on k-nearest neighbors and Transformer attention. It tests quick, accurate reasoning on core ML fundamentals.

    Machine LearningOnline Assessment
  • NetflixEasyMachine Learning Engineer
    Multiply Two Sparse Integer Matrices Given as Dense Grids

    Given two integer matrices stored as dense lists of rows in which most entries are zero, return their exact matrix product. It tests handling matrix dimensions correctly and exploiting sparsity to skip work on zero entries while still producing every entry of the result.

    Coding & AlgorithmsOnline Assessment
  • NetflixHardMachine Learning Engineer
    Review a Feature Pipeline PR for Production Risks, Then Serve Features by Freshness

    Review a feature pipeline pull request whose tests all pass and explain what could break once it runs in production, from time leakage and training-serving skew to data quality and scale. Then decide how the same features should be served when the model needs day-old, minute-fresh or request-time values.

    ML System DesignTechnical Screen
  • NetflixMediumMachine Learning Engineer
    Transform flat keys into nested dictionary

    This question evaluates proficiency in parsing and restructuring hierarchical parameter keys into nested dictionary structures, string manipulation for grouping, handling nonconforming keys and duplicates, and reasoning about time and space complexity.

    Data Manipulation (SQL/Python)Technical Screen