Meta AI Researcher Interview Guide

Most candidates prep their research talk for weeks and barely touch coding. That's backwards for Meta. FAIR's internal culture treats Phabricator diffs and evaluation harnesses as first-class research artifacts, so the interview filters hard on whether you can actually engineer, not just theorize.

Meta AI Researcher Role

You'll spend your days inside FAIR designing experiments, writing PyTorch training code, and presenting results to cross-functional partners on the GenAI product team. The work right now centers on Llama: pretraining data mixtures, post-training alignment pipelines, and evaluation benchmarks that ship as open-source releases. Success looks like a top-venue publication whose methods also showed up in a product team's quarterly roadmap, though the exact bar depends on your level and manager.

A Typical Week

The thing that catches most academics off guard isn't the research time. It's how much of the week is real engineering: debugging data collators, reviewing diffs in Phabricator, writing unit tests for evaluation harnesses. If you've never had a colleague outside your lab scrutinize your code line by line, that adjustment hits fast. The other surprise is how little unstructured exploration exists before Friday, when the pace loosens enough to prototype speculative ideas in Jupyter.

Projects & Impact Areas

Llama pretraining and alignment is the center of gravity, where you'd design RLHF pipelines and evaluation benchmarks that define Meta's open-source positioning. That research feeds directly into Meta AI (the assistant running across WhatsApp, Instagram, and Messenger), so your instruction-following improvements translate into user-facing quality within months. Separately, the ads and recommendation teams pull from FAIR's retrieval and ranking research to handle inference at massive scale under strict latency constraints.

Skills & What's Expected

A strong publication record at NeurIPS, ICML, or CVPR gets you into the pipeline, but what separates offers from rejections is comfort writing production-quality PyTorch, especially distributed training with tools like FSDP. Meta built PyTorch, and the day-in-life reflects that: you'll launch jobs on the Research SuperCluster via fairseq/metaseq, not hand off training scripts to an engineering team. Candidates who can articulate how their research scaled beyond a single GPU or improved a downstream metric consistently outperform those who only talk about novelty.

Levels & Career Growth

The widget shows the level bands. What it won't tell you is where people get stuck: the IC5-to-IC6 jump requires shifting from executing your own research thread to shaping a subarea's agenda and getting other teams to adopt your methods. Internal adoption by product teams carries real weight in the promo committee's evaluation, alongside publication impact and mentorship of junior researchers. Lateral moves into applied ML engineering or research management are common once you've demonstrated that bridge between research and production.

Work Culture

Meta's return-to-office policy requires three days minimum, but the SOURCE DATA culture notes are telling: many FAIR researchers come in more often to access GPU clusters and collaborate in person, so expect the norm to skew toward four or five days. The culture is metrics-driven in a way that can feel uncomfortable if you're coming from academia. Even fundamental research teams track downstream product impact, and your manager will ask how your latest paper connects to Meta's priorities. The upside is genuinely low code ownership barriers: you can read and contribute to nearly any codebase, which makes cross-team collaboration unusually fast.

Meta AI Researcher Compensation

Refresher grants are where Meta's comp structure gets interesting. From what candidates report, annual refreshers for high performers can meaningfully outpace the per-year value of your initial RSU package, which means your total comp in years three and four may look nothing like what your offer letter implied. Sign-on bonuses also tend to come with clawback provisions, so do the math on your minimum tenure before you mentally spend that money.

When negotiating, know that Meta is actively competing with Google DeepMind, OpenAI, and Anthropic for the same small pool of AI researchers, and recruiters price offers accordingly when you can demonstrate overlapping interest from those labs. Equity is where most of the flexibility lives. Push there.

Meta AI Researcher Interview Process

From what candidates report, the end-to-end timeline varies quite a bit. Some people wrap up in a month; others stretch past two months, especially when team matching enters the picture. If you're juggling a deadline from Google DeepMind or Anthropic, surface it in your very first recruiter conversation so the process can be compressed where possible.

Coding is where most research candidates stumble, based on consistent candidate feedback. Meta doesn't offer a lighter version for PhD holders. You'll write real, runnable code in a shared editor against problems that overlap heavily with what software engineers face, so treating this as an afterthought while polishing your research talk is a recipe for a rejection. On the structural side, from what's publicly known, Meta's hiring committee operates separately from any individual team's preferences. Your interviewers submit independent written feedback, and the committee makes its call without a hiring manager advocating for or against you. That's a double-edged sword: no single bad interpersonal dynamic should doom you, but a borderline packet doesn't have an internal champion pulling it across the line either.

Meta AI Researcher Interview Questions

1from typing import List
2
3
4def min_window_watch_time(watch_seconds: List[int], T: int) -> int:
5    """Return length of shortest contiguous subarray with sum >= T, else 0.
6
7    Assumes watch_seconds contains nonnegative integers.
8    """
9    n = len(watch_seconds)
10    if n == 0:
11        return 0
12
13    # If T <= 0, any single element window satisfies sum >= T.
14    if T <= 0:
15        return 1
16
17    best = n + 1
18    left = 0
19    window_sum = 0
20
21    for right, val in enumerate(watch_seconds):
22        window_sum += val
23
24        # Shrink from the left while still meeting the target.
25        while window_sum >= T and left <= right:
26            best = min(best, right - left + 1)
27            window_sum -= watch_seconds[left]
28            left += 1
29
30    return 0 if best == n + 1 else best
31

1import numpy as np
2
3def sigmoid(x: np.ndarray) -> np.ndarray:
4    # Stable sigmoid
5    out = np.empty_like(x, dtype=np.float64)
6    pos = x >= 0
7    neg = ~pos
8    out[pos] = 1.0 / (1.0 + np.exp(-x[pos]))
9    exp_x = np.exp(x[neg])
10    out[neg] = exp_x / (1.0 + exp_x)
11    return out
12
13def bce_with_logits_numpy(logits: np.ndarray, targets: np.ndarray, reduction: str = "mean"):
14    """Binary cross-entropy with logits for multi-label classification.
15
16    Args:
17        logits: shape (N, K)
18        targets: shape (N, K), values in {0,1}
19        reduction: 'mean' or 'sum' or 'none'
20
21    Returns:
22        loss (scalar if reduced, else (N, K)), grad_logits same shape as logits.
23    """
24    logits = logits.astype(np.float64)
25    targets = targets.astype(np.float64)
26
27    # Stable loss: max(z,0) - z*y + log(1 + exp(-|z|))
28    abs_z = np.abs(logits)
29    loss_elem = np.maximum(logits, 0.0) - logits * targets + np.log1p(np.exp(-abs_z))
30
31    # Gradient: sigmoid(z) - y
32    grad = sigmoid(logits) - targets
33
34    if reduction == "none":
35        return loss_elem, grad
36
37    if reduction == "sum":
38        return float(np.sum(loss_elem)), grad
39
40    if reduction == "mean":
41        denom = loss_elem.size
42        return float(np.sum(loss_elem) / denom), grad / denom
43
44    raise ValueError("reduction must be 'none', 'sum', or 'mean'")
45
46
47if __name__ == "__main__":
48    # Quick self-check against PyTorch if available.
49    rng = np.random.default_rng(0)
50    N, K = 8, 5
51    logits = rng.uniform(-50, 50, size=(N, K))
52    targets = rng.integers(0, 2, size=(N, K))
53
54    loss_np, grad_np = bce_with_logits_numpy(logits, targets, reduction="mean")
55
56    try:
57        import torch
58        import torch.nn.functional as F
59
60        t_logits = torch.tensor(logits, dtype=torch.float64, requires_grad=True)
61        t_targets = torch.tensor(targets, dtype=torch.float64)
62        loss_t = F.binary_cross_entropy_with_logits(t_logits, t_targets, reduction="mean")
63        loss_t.backward()
64
65        print("loss numpy:", loss_np)
66        print("loss torch:", loss_t.item())
67        print("max |grad diff|:", np.max(np.abs(grad_np - t_logits.grad.detach().numpy())))
68    except Exception as e:
69        print("PyTorch not available, numpy loss:", loss_np)
70

1from __future__ import annotations
2
3from typing import Dict, Optional
4
5import torch
6
7
8def topk_accuracy(
9    logits: torch.Tensor,
10    targets: torch.Tensor,
11    k: int = 5,
12    mask: Optional[torch.Tensor] = None,
13) -> Dict[str, torch.Tensor]:
14    """Compute top-1 and top-k accuracy for (B,C) or (B,T,C) logits.
15
16    Args:
17        logits: Float tensor shaped (B,C) or (B,T,C).
18        targets: Long tensor shaped (B,) or (B,T).
19        k: top-k.
20        mask: Optional bool or {0,1} tensor shaped (B,T). True means valid.
21
22    Returns:
23        dict with keys 'top1' and f'top{k}', values are scalar tensors.
24    """
25    if logits.dim() not in (2, 3):
26        raise ValueError("logits must have shape (B,C) or (B,T,C)")
27
28    if logits.dim() == 2:
29        # (B,C)
30        B, C = logits.shape
31        if targets.shape != (B,):
32            raise ValueError("targets must have shape (B,) for (B,C) logits")
33        # torch.topk is deterministic given deterministic backend settings.
34        topk_idx = torch.topk(logits, k=min(k, C), dim=-1, largest=True, sorted=True).indices
35        top1_idx = topk_idx[:, 0]
36
37        correct_top1 = (top1_idx == targets).to(torch.float32)
38        correct_topk = (topk_idx == targets[:, None]).any(dim=-1).to(torch.float32)
39
40        return {
41            "top1": correct_top1.mean(),
42            f"top{k}": correct_topk.mean(),
43        }
44
45    # (B,T,C)
46    B, T, C = logits.shape
47    if targets.shape != (B, T):
48        raise ValueError("targets must have shape (B,T) for (B,T,C) logits")
49
50    if mask is None:
51        valid = torch.ones((B, T), device=logits.device, dtype=torch.bool)
52    else:
53        if mask.shape != (B, T):
54            raise ValueError("mask must have shape (B,T)")
55        valid = mask.to(dtype=torch.bool, device=logits.device)
56
57    # Compute top-k indices per frame.
58    topk_idx = torch.topk(logits, k=min(k, C), dim=-1, largest=True, sorted=True).indices  # (B,T,k)
59    top1_idx = topk_idx[..., 0]  # (B,T)
60
61    correct_top1 = (top1_idx == targets) & valid
62    correct_topk = ((topk_idx == targets[..., None]).any(dim=-1) & valid)  # (B,T)
63
64    denom = valid.to(torch.float32).sum().clamp_min(1.0)
65    top1 = correct_top1.to(torch.float32).sum() / denom
66    topk_acc = correct_topk.to(torch.float32).sum() / denom
67
68    return {"top1": top1, f"top{k}": topk_acc}
69
70
71if __name__ == "__main__":
72    torch.manual_seed(0)
73
74    # (B,C) example
75    B, C = 4, 10
76    logits = torch.randn(B, C)
77    targets = torch.randint(0, C, (B,))
78    print(topk_accuracy(logits, targets, k=5))
79
80    # (B,T,C) example with padding mask
81    B, T, C = 2, 6, 7
82    logits_bt = torch.randn(B, T, C)
83    targets_bt = torch.randint(0, C, (B, T))
84    mask = torch.tensor([[1, 1, 1, 1, 0, 0], [1, 1, 1, 0, 0, 0]], dtype=torch.bool)
85    print(topk_accuracy(logits_bt, targets_bt, k=3, mask=mask))
86

1from __future__ import annotations
2
3from dataclasses import dataclass
4from typing import Dict, Iterable, List, Optional, Tuple
5import math
6import numpy as np
7
8
9@dataclass
10class UserDayRow:
11    user_id: int
12    impressions: int
13    clicks: int
14    watch_seconds: float
15
16
17def _safe_int(x) -> int:
18    if x is None:
19        return 0
20    return int(x)
21
22
23def compute_reels_ctr_metrics(
24    rows: List[UserDayRow],
25    n_bootstrap: int = 2000,
26    alpha: float = 0.05,
27    seed: int = 0,
28) -> Dict[str, Optional[float]]:
29    """Compute CTR metrics and a bootstrap CI.
30
31    Returns:
32      - ctr_ratio_of_sums: sum(clicks) / sum(impressions)
33      - ctr_mean_of_user_ctrs: mean over users of (clicks/impressions), skipping users with 0 impressions
34      - ctr_bootstrap_ci_low/high: percentile CI for ratio-of-sums CTR, bootstrapping users
35
36    Notes:
37      - Bootstrapping users (not impressions) matches the typical unit of inference for user-level metrics.
38    """
39
40    if not rows:
41        return {
42            "ctr_ratio_of_sums": None,
43            "ctr_mean_of_user_ctrs": None,
44            "ctr_bootstrap_ci_low": None,
45            "ctr_bootstrap_ci_high": None,
46        }
47
48    # Aggregate to one row per user_id to make the bootstrap unit explicit.
49    by_user: Dict[int, Tuple[int, int]] = {}  # user_id -> (impressions, clicks)
50    for r in rows:
51        imp = _safe_int(r.impressions)
52        clk = _safe_int(r.clicks)
53        if r.user_id in by_user:
54            prev_imp, prev_clk = by_user[r.user_id]
55            by_user[r.user_id] = (prev_imp + imp, prev_clk + clk)
56        else:
57            by_user[r.user_id] = (imp, clk)
58
59    user_ids = list(by_user.keys())
60    imps = np.array([by_user[uid][0] for uid in user_ids], dtype=np.int64)
61    clks = np.array([by_user[uid][1] for uid in user_ids], dtype=np.int64)
62
63    total_imps = int(imps.sum())
64    total_clks = int(clks.sum())
65    ctr_ratio_of_sums = (total_clks / total_imps) if total_imps > 0 else None
66
67    # Mean of per-user CTRs, exclude users with 0 impressions.
68    mask = imps > 0
69    if mask.any():
70        user_ctrs = clks[mask] / imps[mask]
71        ctr_mean_of_user_ctrs = float(user_ctrs.mean())
72    else:
73        ctr_mean_of_user_ctrs = None
74
75    # Bootstrap percentile CI for ratio-of-sums CTR.
76    rng = np.random.default_rng(seed)
77    n_users = len(user_ids)
78    if n_users == 0:
79        return {
80            "ctr_ratio_of_sums": None,
81            "ctr_mean_of_user_ctrs": None,
82            "ctr_bootstrap_ci_low": None,
83            "ctr_bootstrap_ci_high": None,
84        }
85
86    boot_stats = []
87    for _ in range(n_bootstrap):
88        idx = rng.integers(low=0, high=n_users, size=n_users)
89        boot_imps = int(imps[idx].sum())
90        boot_clks = int(clks[idx].sum())
91        if boot_imps == 0:
92            # Degenerate sample, skip or treat as NaN.
93            boot_stats.append(np.nan)
94        else:
95            boot_stats.append(boot_clks / boot_imps)
96
97    boot = np.array(boot_stats, dtype=float)
98    boot = boot[~np.isnan(boot)]
99    if boot.size == 0:
100        ci_low = None
101        ci_high = None
102    else:
103        lo = 100 * (alpha / 2)
104        hi = 100 * (1 - alpha / 2)
105        ci_low = float(np.percentile(boot, lo))
106        ci_high = float(np.percentile(boot, hi))
107
108    return {
109        "ctr_ratio_of_sums": float(ctr_ratio_of_sums) if ctr_ratio_of_sums is not None else None,
110        "ctr_mean_of_user_ctrs": ctr_mean_of_user_ctrs,
111        "ctr_bootstrap_ci_low": ci_low,
112        "ctr_bootstrap_ci_high": ci_high,
113    }
114
115
116if __name__ == "__main__":
117    sample = [
118        UserDayRow(user_id=1, impressions=10, clicks=1, watch_seconds=50.0),
119        UserDayRow(user_id=2, impressions=0, clicks=0, watch_seconds=0.0),
120        UserDayRow(user_id=3, impressions=5, clicks=2, watch_seconds=30.0),
121        UserDayRow(user_id=1, impressions=2, clicks=0, watch_seconds=10.0),
122    ]
123    out = compute_reels_ctr_metrics(sample)
124    for k, v in out.items():
125        print(k, v)
126

1from __future__ import annotations
2
3from dataclasses import dataclass
4from typing import Dict, List, Optional, Tuple
5import numpy as np
6
7
8@dataclass
9class ScoredExample:
10    group_id: int
11    y_true: int  # 0 or 1
12    y_score: float
13
14
15def auc_from_scores(y_true: np.ndarray, y_score: np.ndarray) -> Optional[float]:
16    """Compute ROC AUC using rank statistics.
17
18    Returns None if undefined (all positives or all negatives).
19
20    Handles ties by using average ranks via sorting and tie blocks.
21    Complexity: O(n log n).
22    """
23    y_true = np.asarray(y_true, dtype=np.int8)
24    y_score = np.asarray(y_score, dtype=float)
25
26    n = y_true.size
27    if n == 0:
28        return None
29
30    n_pos = int((y_true == 1).sum())
31    n_neg = n - n_pos
32    if n_pos == 0 or n_neg == 0:
33        return None
34
35    order = np.argsort(y_score, kind="mergesort")  # stable, helps tie handling
36    scores_sorted = y_score[order]
37    y_sorted = y_true[order]
38
39    # Compute average ranks for ties, ranks are 1..n
40    ranks = np.empty(n, dtype=float)
41    i = 0
42    rank = 1
43    while i < n:
44        j = i
45        while j + 1 < n and scores_sorted[j + 1] == scores_sorted[i]:
46            j += 1
47        # Average rank for positions i..j
48        avg_rank = (rank + (rank + (j - i))) / 2.0
49        ranks[i : j + 1] = avg_rank
50        rank += (j - i + 1)
51        i = j + 1
52
53    # Sum ranks of positives
54    sum_ranks_pos = float(ranks[y_sorted == 1].sum())
55
56    # Mann-Whitney U to AUC
57    # U = sum_ranks_pos - n_pos*(n_pos+1)/2
58    u = sum_ranks_pos - (n_pos * (n_pos + 1)) / 2.0
59    auc = u / (n_pos * n_neg)
60    return float(auc)
61
62
63def auc_cluster_bootstrap_ci(
64    examples: List[ScoredExample],
65    n_bootstrap: int = 1000,
66    alpha: float = 0.05,
67    seed: int = 0,
68) -> Dict[str, Optional[float]]:
69    """Compute AUC and a cluster bootstrap CI by resampling group_id."""
70    if not examples:
71        return {"auc": None, "ci_low": None, "ci_high": None}
72
73    # Group examples by cluster.
74    by_group: Dict[int, List[ScoredExample]] = {}
75    for ex in examples:
76        by_group.setdefault(ex.group_id, []).append(ex)
77
78    group_ids = np.array(list(by_group.keys()), dtype=np.int64)
79    g = group_ids.size
80    if g == 0:
81        return {"auc": None, "ci_low": None, "ci_high": None}
82
83    # Point estimate on full data.
84    y_true = np.array([ex.y_true for ex in examples], dtype=np.int8)
85    y_score = np.array([ex.y_score for ex in examples], dtype=float)
86    point = auc_from_scores(y_true, y_score)
87
88    rng = np.random.default_rng(seed)
89    boot_stats = []
90
91    # Pre-store per-group arrays to avoid Python overhead inside bootstrap.
92    group_y_true: Dict[int, np.ndarray] = {}
93    group_y_score: Dict[int, np.ndarray] = {}
94    for gid, lst in by_group.items():
95        group_y_true[gid] = np.array([e.y_true for e in lst], dtype=np.int8)
96        group_y_score[gid] = np.array([e.y_score for e in lst], dtype=float)
97
98    for _ in range(n_bootstrap):
99        sampled = rng.choice(group_ids, size=g, replace=True)
100        # Concatenate selected groups
101        ys = []
102        ss = []
103        for gid in sampled:
104            ys.append(group_y_true[int(gid)])
105            ss.append(group_y_score[int(gid)])
106        yb = np.concatenate(ys) if ys else np.array([], dtype=np.int8)
107        sb = np.concatenate(ss) if ss else np.array([], dtype=float)
108
109        a = auc_from_scores(yb, sb)
110        boot_stats.append(np.nan if a is None else a)
111
112    boot = np.array(boot_stats, dtype=float)
113    boot = boot[~np.isnan(boot)]
114
115    if boot.size == 0:
116        return {"auc": point, "ci_low": None, "ci_high": None}
117
118    lo = 100 * (alpha / 2)
119    hi = 100 * (1 - alpha / 2)
120    ci_low = float(np.percentile(boot, lo))
121    ci_high = float(np.percentile(boot, hi))
122
123    return {"auc": point, "ci_low": ci_low, "ci_high": ci_high}
124
125
126if __name__ == "__main__":
127    data = [
128        ScoredExample(group_id=1, y_true=1, y_score=0.9),
129        ScoredExample(group_id=1, y_true=0, y_score=0.3),
130        ScoredExample(group_id=2, y_true=1, y_score=0.8),
131        ScoredExample(group_id=2, y_true=0, y_score=0.4),
132        ScoredExample(group_id=3, y_true=0, y_score=0.2),
133        ScoredExample(group_id=3, y_true=1, y_score=0.7),
134    ]
135    print(auc_cluster_bootstrap_ci(data, n_bootstrap=500, seed=42))
136

The distribution reveals that Meta's loop is designed to catch one specific candidate profile: the brilliant researcher who can't build production-quality software. Coding and ML system design questions reinforce each other, because a design answer about, say, a retrieval model for Meta AI's assistant falls flat if you can't then sketch an efficient implementation of the candidate generation step in a shared editor. Most PhD candidates underinvest in timed coding practice relative to how much weight it actually carries.

Sharpen both your algorithm skills and research defense instincts with targeted practice at datainterview.com/questions.

How to Prepare for Meta AI Researcher Interviews

Zuckerberg's 2026 roadmap centers on AI-driven ad performance and expanding the Llama open-source ecosystem, while Reality Labs is splitting Quest VR from Worlds (now going mobile-first) to let each product grow independently. Full-year 2025 revenue hit $201B, up 24% year-over-year, which tells you where the funding gravity sits. The PyTorch-native agentic stack Meta recently open-sourced is another signal: research that feeds tool-use, planning, and memory modules has visible executive sponsorship right now.

Most candidates fumble "why Meta" by praising open-source values without specificity. Instead, name something concrete you'd work on: maybe the gap between Llama's agentic planning capabilities and what a production assistant needs, or how the Quest-to-Worlds separation creates new matching and analytics problems for the VR developer ecosystem. Tie your own published work to that gap, and explain what about Meta's particular product surface (ads at that revenue scale, a VR platform actively courting third-party developers, a mobile-first social layer) makes the research tractable here and nowhere else.

Try a Real Interview Question

1from typing import List
2
3
4def softmax_batch(logits: List[List[float]]) -> List[List[float]]:
5    """Compute numerically stable softmax for a batch of logit vectors.
6
7    Args:
8        logits: A list of n vectors, each a list of d floats.
9
10    Returns:
11        A list of n probability vectors, each a list of d floats summing to 1.
12    """
13    pass
14

1from typing import List
2import math
3
4
5def softmax_batch(logits: List[List[float]]) -> List[List[float]]:
6    """Compute numerically stable softmax for a batch of logit vectors.
7
8    Args:
9        logits: A list of n vectors, each a list of d floats.
10
11    Returns:
12        A list of n probability vectors, each a list of d floats summing to 1.
13
14    Raises:
15        ValueError: If logits contains vectors of inconsistent lengths.
16    """
17    if not logits:
18        return []
19
20    d = len(logits[0])
21    for row in logits:
22        if len(row) != d:
23            raise ValueError("All logit vectors must have the same length")
24
25    out: List[List[float]] = []
26    for row in logits:
27        if d == 0:
28            out.append([])
29            continue
30
31        m = row[0]
32        for v in row[1:]:
33            if v > m:
34                m = v
35
36        s = 0.0
37        exps = [0.0] * d
38        for j, v in enumerate(row):
39            ev = math.exp(v - m)
40            exps[j] = ev
41            s += ev
42
43        inv_s = 1.0 / s
44        out.append([ev * inv_s for ev in exps])
45
46    return out
47

The coding round for AI Researchers at Meta isn't a gentler variant of the software engineering interview. If the widget problem above felt uncomfortable, that's a calibration signal worth acting on. Practice at datainterview.com/coding, focusing on graphs, dynamic programming, and array problems until you can produce clean solutions under time pressure.

Test Your Readiness

Quiz yourself on specifics like Meta's Quest vs. Worlds platform split, the VR developer ecosystem strategy, and the agentic stack architecture at datainterview.com/questions.