eBay Machine Learning Engineer Interview Guide

eBay's ML engineers rank 2+ billion live listings where every piece of metadata is seller-generated and wildly inconsistent. That single constraint shapes everything about this role: the models you build, the validation cycles you run, and the infrastructure you operate. If you've only worked with clean, first-party catalog data, the adjustment is real.

eBay Machine Learning Engineer Role

You'll own production ML models for one of eBay's core surfaces: search ranking, promoted listings, recommendations, or fraud detection. These models serve a marketplace where sellers create their own listings with unpredictable quality, so your day-to-day involves as much data debugging and production validation as it does modeling. Year-one success looks like shipping a model change that moves an online metric (search relevance, ad click-through, fraud catch rate) while earning enough operational trust to own your deployment pipeline end-to-end.

A Typical Week

The ratio of production validation to model architecture work will surprise you. Tracing why a listing quality score returns stale values from the feature store, or investigating why item condition fields are blank across an entire category like Collectibles, eats more hours than hyperparameter tuning. The mid-week deep modeling block (refactoring a two-tower retrieval model, adjusting negative sampling) is real, but you earn it by clearing Monday's operational debt first.

Projects & Impact Areas

Search ranking is the gravitational center, where retrieval and re-ranking models must handle seller-created inventory with no standardized catalog to fall back on. Promoted listings ML has grown increasingly strategic as eBay's advertising revenue expands, and those models must balance ad relevance against organic results without eroding buyer trust. Trust & Safety teams (based in Toronto and San Jose) tackle a different flavor of the problem: fraud detection where adversaries actively adapt, forcing retraining and monitoring cycles far tighter than what search ranking requires.

Skills & What's Expected

Deployment and infrastructure skills matter more here than at most peer companies. The provided data rates infrastructure/cloud deployment as "high" and notes that specific cloud vendor details aren't standardized across teams, so you can't assume a single managed platform in system design answers. Modern AI and GenAI knowledge is rated "medium," not negligible. eBay has shipped AI-powered listing tools and the role specialization explicitly includes transformer-based models, so dismissing GenAI entirely would be a mistake. The sweet spot is someone who pairs classical ranking and recommendation depth with real production engineering chops (pipeline orchestration, inference serving, monitoring).

Levels & Career Growth

T24 (Senior) and T25 (Staff) are the levels that appear most often in current external ML job postings. The jump from T24 to T25 is the hardest promotion because it demands multi-team influence and platform-level thinking, not just shipping great models within your own pod. eBay uses "MTS" (Member of Technical Staff) titles alongside T-levels, which confuses external candidates: MTS-1 maps roughly to T23, MTS-2 to T24, and T26 Principal MTS roles show up in active postings with real architectural scope.

Work Culture

eBay's hybrid model has most ML engineers in-office Tuesday through Thursday at the San Jose campus (Austin and Bengaluru are the other major hubs), with Monday and Friday commonly remote. With roughly 12,000 employees globally, you get more direct product influence than you would at a company ten times that size, though internal mobility options are narrower if your team's charter shifts. eBay's mission around "economic opportunity for all" shows up in practice: ML teams actively debate ranking fairness for small sellers rather than optimizing purely for GMV.

eBay Machine Learning Engineer Compensation

eBay does not publicly disclose its RSU vesting schedule. The data that exists for other large tech companies (Amazon's backloaded structure, Google's even quarterly vest) simply can't be projected onto eBay. Ask your recruiter directly about cliff periods, vesting cadence, and, most importantly, refresh grant policies before you sign anything.

The negotiation data provided in the widget shows wide bands at T25 and T26, with a $220k+ spread between min and max total comp. That range is your signal: at Staff and above, there's real room to move. Your strongest lever is anchoring on the specific scope of the role you're being hired for (owning search ranking models across 2B+ listings, for example, or leading fraud detection for a global marketplace) rather than relying on generic competing-offer tactics. Equity and sign-on amounts are where conversations tend to have the most flexibility, so push there with concrete numbers tied to what you'd be leaving behind.

eBay Machine Learning Engineer Interview Process

The Hiring Manager Screen is where most candidates lose momentum. eBay's ML hiring managers tend to probe deeply on one past project, asking you to walk through offline evaluation, online A/B results, and production constraints like latency budgets or monitoring. From what candidates report, surface-level answers about "building a model" without specific metrics (NDCG lift, fraud catch rate, serving latency) make it hard to advance past this stage.

The SQL & Data Modeling round is the other common stumble point, especially for ML engineers who've lived in notebook environments. eBay's marketplace data involves massive event tables (impressions, clicks, purchases across 2B+ listings) and interviewers expect fluent window functions and complex joins under time pressure. If you're strong on ML but rusty on SQL, that gap alone can cost you the offer, so budget real prep time there.

eBay Machine Learning Engineer Interview Questions

1from pyspark.sql import functions as F, Window
2
3# Inputs
4# clicks schema: user_id, click_id, event_time (timestamp), ingestion_time (timestamp), ad_id
5# feature_date is derived from event_time in UTC
6
7raw = clicks.select(
8    "user_id",
9    "click_id",
10    F.col("event_time").alias("event_ts"),
11    F.col("ingestion_time").alias("ingest_ts")
12)
13
14# Dedup using click_id, keep the earliest event_ts (or latest ingest_ts, but be consistent)
15w = Window.partitionBy("click_id").orderBy(F.col("event_ts").asc(), F.col("ingest_ts").desc())
16
17dedup = (raw
18    .withColumn("rn", F.row_number().over(w))
19    .filter(F.col("rn") == 1)
20    .drop("rn")
21)
22
23# Compute feature_date by event time (UTC)
24dedup = dedup.withColumn("feature_date", F.to_date(F.col("event_ts")))
25
26# Bound the recompute window to handle 48h lateness, for a given run_date
27run_date = F.to_date(F.lit("2026-02-26"))
28start_date = F.date_sub(run_date, 2)
29end_date = run_date
30
31bounded = dedup.filter((F.col("feature_date") >= start_date) & (F.col("feature_date") <= end_date))
32
33# 30d rolling clicks per user for each feature_date
34# Build daily counts then roll up 30d
35user_day = (bounded
36    .groupBy("user_id", "feature_date")
37    .agg(F.count("click_id").alias("clicks_1d"))
38)
39
40roll_w = Window.partitionBy("user_id").orderBy(F.col("feature_date").cast("timestamp")).rowsBetween(-29, 0)
41
42features = (user_day
43    .withColumn("user_30d_ad_clicks", F.sum("clicks_1d").over(roll_w))
44    .select("user_id", "feature_date", "user_30d_ad_clicks")
45)
46
47# Idempotent write pattern: overwrite only impacted partitions (feature_date) for the bounded window
48# In practice use a table format with MERGE/REPLACE WHERE, or dynamic partition overwrite.
49(
50    features
51    .write
52    .mode("overwrite")
53    .partitionBy("feature_date")
54    .format("parquet")
55    .save("s3://bucket/features/user_30d_ad_clicks/")
56)
57

1from __future__ import annotations
2
3import math
4from typing import Dict, Iterable, List, Sequence, Tuple
5
6
7def ndcg_at_k(
8    per_query_results: Dict[str, Sequence[Tuple[float, int]]],
9    k: int,
10    *,
11    zero_idcg_policy: str = "zero",
12) -> float:
13    """Compute mean NDCG@k across queries.
14
15    Args:
16        per_query_results: Mapping query_id -> sequence of (score, relevance).
17            The sequence can be in any order, it will be sorted by score desc.
18        k: Cutoff.
19        zero_idcg_policy: What to return for a query with IDCG@k == 0.
20            "zero" -> NDCG = 0.0, "skip" -> exclude from mean.
21
22    Returns:
23        Mean NDCG@k.
24    """
25    if k <= 0:
26        raise ValueError("k must be positive")
27
28    def dcg(rels: List[int]) -> float:
29        total = 0.0
30        for i, rel in enumerate(rels[:k], start=1):
31            gain = (2 ** rel) - 1
32            denom = math.log2(i + 1)
33            total += gain / denom
34        return total
35
36    ndcgs: List[float] = []
37
38    for qid, items in per_query_results.items():
39        # Sort by model score descending. Stable sort helps deterministic tie handling.
40        sorted_by_score = sorted(items, key=lambda x: x[0], reverse=True)
41        rels_ranked = [rel for _, rel in sorted_by_score]
42        rels_ideal = sorted([rel for _, rel in items], reverse=True)
43
44        dcg_k = dcg(rels_ranked)
45        idcg_k = dcg(rels_ideal)
46
47        if idcg_k == 0.0:
48            if zero_idcg_policy == "skip":
49                continue
50            if zero_idcg_policy == "zero":
51                ndcgs.append(0.0)
52                continue
53            raise ValueError(f"Unknown zero_idcg_policy: {zero_idcg_policy}")
54
55        ndcgs.append(dcg_k / idcg_k)
56
57    return float(sum(ndcgs) / len(ndcgs)) if ndcgs else 0.0
58
59
60if __name__ == "__main__":
61    # Example usage
62    data = {
63        "q1": [(0.9, 3), (0.2, 0), (0.1, 2)],
64        "q2": [(0.3, 0), (0.2, 0)],  # all-zero relevance
65    }
66    print(ndcg_at_k(data, k=3))
67

1from __future__ import annotations
2
3import math
4from typing import Iterable, List, Tuple
5
6
7def _sigmoid(x: float) -> float:
8    # Numerically stable sigmoid
9    if x >= 0:
10        z = math.exp(-x)
11        return 1.0 / (1.0 + z)
12    z = math.exp(x)
13    return z / (1.0 + z)
14
15
16def _logit(p: float, eps: float = 1e-12) -> float:
17    # Clip to avoid inf
18    p = min(1.0 - eps, max(eps, p))
19    return math.log(p) - math.log(1.0 - p)
20
21
22def _nll_of_T(logits: List[float], labels: List[int], T: float) -> float:
23    # NLL = -sum(y*log(q) + (1-y)*log(1-q)) where q = sigmoid(logit/T)
24    if T <= 0:
25        return float("inf")
26    total = 0.0
27    for z, y in zip(logits, labels):
28        q = _sigmoid(z / T)
29        # Clip q for log stability
30        q = min(1.0 - 1e-15, max(1e-15, q))
31        total += -(y * math.log(q) + (1 - y) * math.log(1.0 - q))
32    return total
33
34
35def fit_temperature_scaling(
36    p_val: Iterable[float],
37    y_val: Iterable[int],
38    *,
39    T_min: float = 0.05,
40    T_max: float = 10.0,
41    steps: int = 200,
42) -> float:
43    """Fit temperature T via grid search on validation NLL.
44
45    This is simple, robust, and interview-friendly. In production you might
46    use LBFGS on T in log-space.
47    """
48    p_list = list(p_val)
49    y_list = list(y_val)
50    if len(p_list) != len(y_list) or len(p_list) == 0:
51        raise ValueError("p_val and y_val must be same non-zero length")
52
53    logits = [_logit(p) for p in p_list]
54
55    best_T = 1.0
56    best_loss = float("inf")
57
58    # Search in log-space for better coverage.
59    log_min = math.log(T_min)
60    log_max = math.log(T_max)
61    for i in range(steps):
62        t = math.exp(log_min + (log_max - log_min) * (i / (steps - 1)))
63        loss = _nll_of_T(logits, y_list, t)
64        if loss < best_loss:
65            best_loss = loss
66            best_T = t
67
68    return best_T
69
70
71def apply_temperature_scaling(p: Iterable[float], T: float) -> List[float]:
72    """Apply calibrated probabilities q = sigmoid(logit(p)/T)."""
73    if T <= 0:
74        raise ValueError("T must be positive")
75    out: List[float] = []
76    for pi in p:
77        zi = _logit(pi)
78        out.append(_sigmoid(zi / T))
79    return out
80
81
82if __name__ == "__main__":
83    p_val = [0.9, 0.8, 0.2, 0.1, 0.55, 0.6]
84    y_val = [1, 1, 0, 0, 0, 1]
85    T = fit_temperature_scaling(p_val, y_val)
86    print("T:", T)
87    print(apply_temperature_scaling([0.05, 0.5, 0.95], T))
88

eBay's question mix rewards candidates who can trace a model from whiteboard sketch all the way through a canary rollout on live marketplace traffic, then diagnose why conversion dropped even though CTR held steady. Where this gets uniquely hard is the interplay between design and operations: a search reranker prompt doesn't end when you draw the architecture, because interviewers will pivot to asking how you'd detect training/serving skew when seller-generated listing metadata shifts daily in ways a curated catalog never would. The prep mistake that costs the most time is drilling applied modeling theory in isolation while ignoring the experimentation scenarios where eBay's two-sided marketplace creates interference (ranking changes alter seller pricing behavior, contaminating your control group) and the pipeline scenarios where late-arriving click data breaks feature parity.

Sharpen your prep with eBay-style ML interview questions at datainterview.com/questions.

How to Prepare for eBay Machine Learning Engineer Interviews

eBay's Q4 2025 earnings show $11.1 billion in revenue (up 15% YoY), and the company's north star priorities center on AI-powered seller tools, search personalization, and trust. Their engineering team published a candid breakdown of GenAI's actual impact on developer productivity, measuring what works and what doesn't rather than chasing hype. Read it before your loop, because eBay's ML culture skews empirical, and interviewers notice when candidates can speak to that measurement-first posture.

The "why eBay" answer that falls flat is any version of "marketplace scale excites me." What separates strong candidates: connecting your experience to a problem only eBay's two-sided marketplace creates. Maybe you've dealt with ranking under inconsistent metadata (eBay's 2B+ seller-generated listings have wildly uneven quality), or you've run A/B tests where treatment effects leak across user groups the way seller behavior shifts do when eBay changes ranking. eBay also designs its own server hardware and has open-sourced those designs, so if you've optimized model serving under hardware constraints rather than just scaling up cloud instances, say so.

Try a Real Interview Question

1def roc_auc(y_true, y_score):
2    """Compute ROC AUC for binary labels with tie-aware average ranks.
3
4    Args:
5        y_true: List[int] of 0/1 labels.
6        y_score: List[float] of predicted scores.
7
8    Returns:
9        float AUC in [0, 1]. If y_true has no positive or no negative labels, return 0.5.
10    """
11    pass
12

1def roc_auc(y_true, y_score):
2    """Compute ROC AUC for binary labels with tie-aware average ranks.
3
4    Args:
5        y_true: List[int] of 0/1 labels.
6        y_score: List[float] of predicted scores.
7
8    Returns:
9        float AUC in [0, 1]. If y_true has no positive or no negative labels, return 0.5.
10
11    Notes:
12        Uses the rank-based formula:
13            AUC = (sum_ranks_pos - n_pos*(n_pos+1)/2) / (n_pos*n_neg)
14        with average ranks for tied scores.
15    """
16    if y_true is None or y_score is None:
17        raise ValueError("y_true and y_score must be provided")
18    if len(y_true) != len(y_score):
19        raise ValueError("y_true and y_score must have the same length")
20
21    n = len(y_true)
22    if n == 0:
23        raise ValueError("inputs must be non-empty")
24
25    n_pos = 0
26    n_neg = 0
27    for y in y_true:
28        if y not in (0, 1):
29            raise ValueError("y_true must contain only 0/1")
30        if y == 1:
31            n_pos += 1
32        else:
33            n_neg += 1
34
35    if n_pos == 0 or n_neg == 0:
36        return 0.5
37
38    pairs = list(zip(y_score, y_true))
39    pairs.sort(key=lambda t: t[0])
40
41    sum_ranks_pos = 0.0
42    rank = 1  # 1-based ranks
43    i = 0
44    while i < n:
45        j = i + 1
46        score_i = pairs[i][0]
47        while j < n and pairs[j][0] == score_i:
48            j += 1
49
50        # average rank for indices [i, j)
51        # ranks are rank .. rank + (j-i) - 1
52        k = j - i
53        avg_rank = (rank + (rank + k - 1)) / 2.0
54
55        # add avg_rank for each positive in the tie group
56        pos_in_group = 0
57        for t in range(i, j):
58            if pairs[t][1] == 1:
59                pos_in_group += 1
60        sum_ranks_pos += pos_in_group * avg_rank
61
62        rank += k
63        i = j
64
65    auc = (sum_ranks_pos - (n_pos * (n_pos + 1)) / 2.0) / (n_pos * n_neg)
66
67    # Numerical safety: clamp to [0,1]
68    if auc < 0.0:
69        return 0.0
70    if auc > 1.0:
71        return 1.0
72    return float(auc)
73

eBay's ML coding round leans toward problems where you process marketplace signals or build scoring logic in Python, not isolated algorithm exercises. The widget above gives you a feel for that flavor. Build your muscle memory with more ML-oriented coding problems at datainterview.com/coding.

Test Your Readiness

This quiz covers the mix of ranking, experimentation, and production ML topics that eBay's onsite emphasizes. Identify your weak spots, then go deeper at datainterview.com/questions.