Duolingo Machine Learning Engineer Interview Guide

From what candidates tell us, Duolingo's coding bar is the part that catches ML specialists off guard. The role demands expert-level software engineering alongside expert-level ML, and if your algorithm skills are rusty, strong modeling chops alone won't carry you through.

Duolingo Machine Learning Engineer Role

Birdbrain, Duolingo's ML-powered lesson sequencing system, shows up in your first week and never leaves your screen. You'll work on the models that decide when learners see vocabulary again, how exercise difficulty gets calibrated, and which content surfaces next. ML engineers here own the full loop: feature engineering, model training, production deployment, and experiment analysis. Nobody hands off code to a separate platform team.

A Typical Week

The coding-heavy split is the thing that makes this role feel more like a software engineering job than most ML positions. You're not spending your days in notebooks and slide decks. Debugging a flaky training pipeline on Tuesday, writing PyTorch feature transformations on Wednesday, reviewing a teammate's PR on Thursday. Design docs and experiment plans also claim a real chunk of the week, because Duolingo's "test it first" culture means you write up latency benchmarks and success metrics before anyone greenlights a launch.

Projects & Impact Areas

Birdbrain's spaced repetition models decide when to resurface vocabulary and how to score exercise difficulty differently across language families (character-based vs. Romance languages, for example, require very different calibration). Newer product lines like Duolingo Math and Music are where greenfield ML work lives, since those surfaces need recommendation and sequencing approaches built from scratch rather than inherited from the language learning stack.

Skills & What's Expected

Software engineering is rated expert-level, not "nice to have," and that's what filters people out. ML depth is also rated expert, but most candidates already prep for that. The surprise is the algorithms bar. Meanwhile, GenAI knowledge is rated low. The skill profile emphasizes probabilistic models (BG/NBD, Gamma-Gamma), Bayesian vs. Frequentist reasoning, and classical ML paradigms like supervised, unsupervised, and reinforcement learning. Your comfort with stats and probability matters far more here than your opinions on the latest foundation model.

Levels & Career Growth

Growth at Duolingo tends to come from owning a new product surface end-to-end rather than managing people. From what we can tell, the jump between levels hinges on driving cross-functional alignment with curriculum and product teams who think in pedagogical terms, not model metrics. That soft skill is harder to develop than any technical gap.

Work Culture

Based on employee accounts, most people work from Duolingo's Pittsburgh office on a regular basis, though the exact policy isn't publicly documented. The pace is fast but not a burnout shop. The company offers a two-week winter break, and the day-to-day rhythm described by engineers suggests people wrap up at a reasonable hour. Duolingo's published operating principles ("test it first," "reduce complexity," "bias toward action") aren't just wall art; they shape how experiment launches get approved and how design docs get reviewed.

Duolingo Machine Learning Engineer Compensation

Duolingo's RSUs follow a four-year vesting schedule at roughly 25% per year, though the source data doesn't specify whether that includes a one-year cliff or quarterly vesting from day one. Ask your recruiter to clarify the exact vesting mechanics before you sign, because that distinction determines whether you're waiting 12 months for your first equity payout or receiving it much sooner.

Base salary, RSU grant size, and sign-on bonus are all negotiable components at Duolingo, from what candidates report. Your strongest play is bringing a competing offer to the table, then focusing the conversation on the RSU grant or sign-on rather than trying to stretch all three simultaneously. Duolingo's ML team is small enough that each hire fills a visible gap in their adaptive learning or NLP pipelines, which gives you more leverage than you might expect from a company of ~700 people.

Duolingo Machine Learning Engineer Interview Process

The most common reason candidates get rejected is weak coding fundamentals. Duolingo's second coding round has you working inside an existing codebase, collaborating with an interviewer on feature integration and debugging in Python or Java. That's a different muscle than solving isolated algorithm puzzles, and ML specialists who live in notebooks often struggle with it.

The two rounds labeled "behavioral" are misleading. One is actually a code review session where you evaluate someone else's code for bugs, maintainability, and engineering best practices. Only the final round covers traditional behavioral territory, probing how you've shipped ML products that connect to real user outcomes. From what candidates report, Duolingo's hiring committee cares whether you can tie model improvements back to learner efficacy (think lesson completion, retention curves across their 40+ language courses), not just offline metrics.

Duolingo Machine Learning Engineer Interview Questions

from typing import Optional


def longest_streak_with_k_wrongs(outcomes: str, k: int) -> int:
    """Return the max length of a contiguous window with at most k '0's.

    Args:
        outcomes: String of '1' and '0' in chronological order.
        k: Maximum number of wrong answers allowed in the window.

    Returns:
        Length of the longest valid window.
    """
    if k < 0:
        return 0
    n = len(outcomes)
    left = 0
    zeros = 0
    best = 0

    for right in range(n):
        if outcomes[right] == '0':
            zeros += 1

        while zeros > k and left <= right:
            if outcomes[left] == '0':
                zeros -= 1
            left += 1

        best = max(best, right - left + 1)

    return best


if __name__ == "__main__":
    assert longest_streak_with_k_wrongs("", 2) == 0
    assert longest_streak_with_k_wrongs("111", 0) == 3
    assert longest_streak_with_k_wrongs("101001", 1) == 3  # "101" or "100"
    assert longest_streak_with_k_wrongs("000", 2) == 2

from __future__ import annotations

from collections import defaultdict
import heapq
from typing import Iterable, List, Tuple


def top_k_items_by_distinct_users(
    events: Iterable[Tuple[int, int]],
    k: int,
) -> List[int]:
    """Top-k items by distinct user count.

    Args:
        events: Iterable of (user_id, item_id) pairs.
        k: Number of items to return.

    Returns:
        List of item_ids sorted by distinct-user count desc, then item_id asc.
    """
    if k <= 0:
        return []

    users_per_item = defaultdict(set)
    for user_id, item_id in events:
        users_per_item[item_id].add(user_id)

    # Min-heap of (count, -item_id) so that the worst element is on top.
    # We want to keep larger counts, and for ties we want smaller item_id.
    heap: List[Tuple[int, int]] = []

    for item_id, users in users_per_item.items():
        count = len(users)
        entry = (count, -item_id)

        if len(heap) < k:
            heapq.heappush(heap, entry)
        else:
            # Replace if strictly better than the current worst.
            if entry > heap[0]:
                heapq.heapreplace(heap, entry)

    # Convert heap to sorted output: count desc, item_id asc.
    result = [(-neg_item_id, count) for count, neg_item_id in heap]
    result.sort(key=lambda x: (-x[1], x[0]))
    return [item_id for item_id, _ in result]


if __name__ == "__main__":
    events = [
        (1, 10), (2, 10), (1, 10),  # item 10 has users {1,2}
        (3, 20),
        (4, 20), (4, 30),
        (5, 30),
        (6, 40),
    ]
    assert top_k_items_by_distinct_users(events, 2) == [10, 20]
    assert top_k_items_by_distinct_users(events, 3) == [10, 20, 30]

import math
import random
from dataclasses import dataclass
from typing import Tuple, Dict, Any, Optional

import numpy as np
import torch
from torch import nn
from torch.utils.data import DataLoader, TensorDataset


def set_seed(seed: int = 42) -> None:
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)


def train_val_split(
    X: np.ndarray,
    y: np.ndarray,
    val_frac: float = 0.2,
    seed: int = 42
) -> Tuple[Tuple[np.ndarray, np.ndarray], Tuple[np.ndarray, np.ndarray]]:
    """Deterministic split. No shuffling inside DataLoader for validation."""
    assert X.ndim == 2
    assert y.ndim == 1
    assert len(X) == len(y)
    n = len(X)
    idx = np.arange(n)
    rng = np.random.default_rng(seed)
    rng.shuffle(idx)
    n_val = int(round(n * val_frac))
    val_idx = idx[:n_val]
    tr_idx = idx[n_val:]
    return (X[tr_idx], y[tr_idx]), (X[val_idx], y[val_idx])


def binary_auc(y_true: np.ndarray, y_score: np.ndarray) -> float:
    """Compute ROC AUC from scratch using rank statistics.

    Handles ties by assigning average ranks.
    Returns 0.5 if AUC is undefined (all positives or all negatives).
    """
    y_true = np.asarray(y_true).astype(int)
    y_score = np.asarray(y_score).astype(float)
    assert y_true.shape == y_score.shape

    n_pos = int((y_true == 1).sum())
    n_neg = int((y_true == 0).sum())
    if n_pos == 0 or n_neg == 0:
        return 0.5

    order = np.argsort(y_score)
    scores_sorted = y_score[order]
    y_sorted = y_true[order]

    ranks = np.empty_like(scores_sorted, dtype=float)
    i = 0
    rank = 1
    while i < len(scores_sorted):
        j = i
        while j + 1 < len(scores_sorted) and scores_sorted[j + 1] == scores_sorted[i]:
            j += 1
        avg_rank = (rank + (rank + (j - i))) / 2.0
        ranks[i:j + 1] = avg_rank
        rank += (j - i + 1)
        i = j + 1

    sum_ranks_pos = ranks[y_sorted == 1].sum()
    auc = (sum_ranks_pos - (n_pos * (n_pos + 1) / 2.0)) / (n_pos * n_neg)
    return float(auc)


class MLPBinaryClassifier(nn.Module):
    def __init__(self, d_in: int, hidden: int = 64, dropout: float = 0.1):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(d_in, hidden),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(hidden, 1)
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return self.net(x).squeeze(-1)  # logits


@dataclass
class TrainConfig:
    batch_size: int = 256
    lr: float = 1e-3
    weight_decay: float = 1e-5
    epochs: int = 50
    patience: int = 5
    seed: int = 42
    device: str = "cpu"


def train_model_auc_early_stop(
    X: np.ndarray,
    y: np.ndarray,
    config: TrainConfig,
    val_frac: float = 0.2
) -> Dict[str, Any]:
    set_seed(config.seed)

    (X_tr, y_tr), (X_va, y_va) = train_val_split(X, y, val_frac=val_frac, seed=config.seed)

    X_tr_t = torch.tensor(X_tr, dtype=torch.float32)
    y_tr_t = torch.tensor(y_tr, dtype=torch.float32)
    X_va_t = torch.tensor(X_va, dtype=torch.float32)
    y_va_t = torch.tensor(y_va, dtype=torch.float32)

    tr_loader = DataLoader(TensorDataset(X_tr_t, y_tr_t), batch_size=config.batch_size, shuffle=True)
    va_loader = DataLoader(TensorDataset(X_va_t, y_va_t), batch_size=config.batch_size, shuffle=False)

    model = MLPBinaryClassifier(d_in=X.shape[1]).to(config.device)
    opt = torch.optim.AdamW(model.parameters(), lr=config.lr, weight_decay=config.weight_decay)
    loss_fn = nn.BCEWithLogitsLoss()

    best_auc = -math.inf
    best_state: Optional[Dict[str, torch.Tensor]] = None
    bad_epochs = 0

    for epoch in range(1, config.epochs + 1):
        model.train()
        total_loss = 0.0
        n_seen = 0
        for xb, yb in tr_loader:
            xb = xb.to(config.device)
            yb = yb.to(config.device)
            opt.zero_grad(set_to_none=True)
            logits = model(xb)
            loss = loss_fn(logits, yb)
            loss.backward()
            opt.step()
            bs = len(xb)
            total_loss += float(loss.item()) * bs
            n_seen += bs
        train_loss = total_loss / max(1, n_seen)

        model.eval()
        all_probs = []
        all_true = []
        with torch.no_grad():
            for xb, yb in va_loader:
                xb = xb.to(config.device)
                logits = model(xb)
                probs = torch.sigmoid(logits).cpu().numpy()
                all_probs.append(probs)
                all_true.append(yb.numpy())
        y_prob = np.concatenate(all_probs)
        y_true = np.concatenate(all_true).astype(int)
        val_auc = binary_auc(y_true, y_prob)

        if val_auc > best_auc + 1e-6:
            best_auc = val_auc
            best_state = {k: v.detach().cpu().clone() for k, v in model.state_dict().items()}
            bad_epochs = 0
        else:
            bad_epochs += 1
            if bad_epochs >= config.patience:
                break

    if best_state is not None:
        model.load_state_dict(best_state)

    return {
        "model": model,
        "best_val_auc": best_auc,
        "train_size": len(X_tr),
        "val_size": len(X_va)
    }


if __name__ == "__main__":
    # Demo with synthetic data (replace with Duolingo feature matrix and labels).
    set_seed(42)
    n, d = 5000, 20
    X = np.random.normal(size=(n, d)).astype(np.float32)
    w = np.random.normal(size=(d,)).astype(np.float32)
    logits = X @ w
    p = 1.0 / (1.0 + np.exp(-logits))
    y = (np.random.uniform(size=(n,)) < p).astype(np.int64)

    cfg = TrainConfig(device="cpu")
    out = train_model_auc_early_stop(X, y, cfg)
    print({"best_val_auc": out["best_val_auc"], "train_size": out["train_size"], "val_size": out["val_size"]})

The compounding challenge here isn't any single area. It's that Duolingo's loop pairs heavy code output with deep probabilistic reasoning about learner behavior, so you'll need to implement something like a BG/NBD model in PyTorch and defend your uncertainty estimates to an interviewer who knows forgetting curves cold. Most MLE candidates prep modeling and algorithms as separate tracks, but Duolingo's questions frequently blend them, asking you to code a working training loop for a model rooted in the same Gamma-Gamma or retention-probability math you discussed minutes earlier.

Sharpen that overlap at datainterview.com/questions, where you can drill the stats-meets-implementation style Duolingo favors.

How to Prepare for Duolingo Machine Learning Engineer Interviews

Duolingo pulled in $964M in revenue with 41% year-over-year growth, yet the company runs with roughly 830 employees. That lean headcount signals something about how they build: their company strategy overview frames the next chapter as evolving from a language app into a broader education platform, with new subjects and a push to bridge online learning with real-world impact. For ML engineers, this means the product surface is expanding faster than the team.

Your "why Duolingo" answer needs to go beyond the product itself. Duolingo's operating principles emphasize data-driven decisions and measuring whether users are actually learning, not just opening the app. Reference that distinction, then connect it to something from their Scala backend rewrite or their strategy around making Duolingo a credible professional credential. Specificity about their engineering choices and educational mission beats enthusiasm about the owl every time.

Try a Real Interview Question

from typing import Iterable, Optional, Tuple


def auc_from_stream(examples: Iterable[Tuple[int, float]]) -> Optional[float]:
    """Compute AUC from a stream of (label, score) pairs.

    Args:
        examples: Iterable of (y, s) where y is 0/1 and s is a float.

    Returns:
        AUC as float, or None if there are no positive or no negative labels.
    """
    pass

from typing import Iterable, Optional, Tuple


def auc_from_stream(examples: Iterable[Tuple[int, float]]) -> Optional[float]:
    """Compute AUC from a stream of (label, score) pairs.

    Uses a sorting-based computation with correct handling of ties.

    Args:
        examples: Iterable of (y, s) where y is 0/1 and s is a float.

    Returns:
        AUC as float, or None if there are no positive or no negative labels.

    Raises:
        ValueError: If a label is not 0 or 1.
    """
    data = []
    n_pos = 0
    n_neg = 0

    for y, s in examples:
        if y not in (0, 1):
            raise ValueError(f"Label must be 0 or 1, got {y!r}")
        data.append((float(s), int(y)))
        if y == 1:
            n_pos += 1
        else:
            n_neg += 1

    if n_pos == 0 or n_neg == 0:
        return None

    # Sort by score ascending. AUC can be computed from the sum of ranks of positives.
    data.sort(key=lambda t: t[0])

    # Assign average ranks for ties.
    # Ranks are 1-based.
    sum_pos_ranks = 0.0
    rank = 1
    i = 0
    n = len(data)

    while i < n:
        j = i
        score_i = data[i][0]
        pos_in_group = 0

        while j < n and data[j][0] == score_i:
            if data[j][1] == 1:
                pos_in_group += 1
            j += 1

        group_size = j - i
        avg_rank = (rank + (rank + group_size - 1)) / 2.0
        sum_pos_ranks += pos_in_group * avg_rank

        rank += group_size
        i = j

    # Mann-Whitney U statistic for positives.
    u_pos = sum_pos_ranks - (n_pos * (n_pos + 1)) / 2.0
    auc = u_pos / (n_pos * n_neg)
    return float(auc)

Duolingo's own engineering blog on interviewing makes clear that strong software engineering ability is a hard requirement, not a bonus. The coding rounds reward clean, production-quality solutions with time left to discuss tradeoffs. Practice consistently at datainterview.com/coding.

Test Your Readiness

Use this to find your weak spots before committing to a full prep cycle, then close the gaps at datainterview.com/questions.