Etsy Machine Learning Engineer Interview Guide

At most e-commerce companies, ML engineers optimize recommendations for products that get purchased thousands of times. Etsy's catalog is different: handmade and vintage items with inconsistent seller descriptions, unpredictable inventory, and search queries that read more like mood boards than product lookups. From what we've seen in mock interviews, candidates who prep with standard e-commerce system design get caught off guard by how much Etsy's constraints change the problem.

Etsy Machine Learning Engineer Role

Your first year is about owning a model end-to-end, from feature pipeline through production serving and A/B testing. Success means you've shipped a signal into the search ranking system, measured its impact on conversion or gross merchandise sales, and presented results to the broader team. You're not handing off notebooks. You're writing the deployment config too.

A Typical Week

The infrastructure slice is bigger than most candidates expect. You'll spend real time reviewing monitoring dashboards after model pushes, debugging flaky CI jobs in the training pipeline, and prepping deployment configs. The meeting load stays light thanks to Etsy's small-pod structure, where async Slack threads handle most coordination. Deep feature engineering blocks land mid-week, with collaboration and release prep bookending the schedule.

Projects & Impact Areas

Search relevance anchors the ML roadmap. Etsy's team has published work on using LLMs to rewrite the messy, creative queries buyers type (think "cottagecore ceramic mug for plant lover"), and ML engineers build the retrieval and ranking stages that surface relevant results from a catalog full of unique, low-inventory items. That same ranking infrastructure feeds into ads relevance, while a quieter set of seller-side ML problems (listing optimization, pricing suggestions) serves creative entrepreneurs who have no data science resources of their own.

Skills & What's Expected

The underrated skill here is information retrieval and practical NLP. Embeddings, transformer-based retrieval, and query rewriting map directly to the search work that dominates the team's roadmap. Deep computer vision expertise? Overrated for this seat. Etsy's ML problems live in text, behavioral signals, and sparse interaction data. The balanced skill profile means they want someone comfortable writing production feature pipelines, not just tuning hyperparameters in a notebook.

Levels & Career Growth

The jump from Senior to Staff at Etsy requires cross-team influence: redesigning a shared feature store interface, or defining the evaluation framework that multiple pods adopt. Etsy's ML org is small enough that your work is visible to leadership, but that cuts both ways. Promotion timelines can feel less predictable than at companies with thousands of ML engineers and well-worn rubrics. The dual IC/management ladder is real (they actively hire Engineering Managers for ML), so you won't be pushed into people management to keep growing.

Work Culture

Etsy runs hybrid out of Brooklyn HQ, with many ML engineers clustering in-office on Wednesdays and Thursdays for design reviews and collaboration. The pace is deliberately sustainable, with 9:30-to-5:30 days as the norm and minimal after-hours expectations. The "Code as Craft" identity shows up in practice: writing up experiment results and contributing to internal tooling are things that get noticed. The tradeoff is that Etsy expects you to connect model improvements to business outcomes. If you can't explain why an NDCG gain matters for buyer satisfaction or GMS, you'll struggle to get buy-in for your next project.

Etsy Machine Learning Engineer Compensation

Etsy's equity and vesting details aren't publicly documented in a standardized way, so ask your recruiter directly about the RSU schedule, cliff, and refresh policy during the offer conversation. Don't assume it mirrors a FAANG-style structure. Getting these specifics in writing before you sign protects you from surprises, especially since equity value at any public company shifts with the stock price.

Your single biggest negotiation lever: Etsy's search and ranking work sits on a genuinely unusual problem space (one-of-a-kind inventory, seller-generated descriptions, LLM-powered query rewriting), which shrinks the pool of candidates who can speak credibly to those challenges. A competing offer, from any company, gives you room to push on whichever comp components the recruiter signals are flexible. Ask explicitly which levers they can move rather than guessing.

Etsy Machine Learning Engineer Interview Process

Timelines vary, and no public data pins down Etsy's exact cadence. From what candidates report, the process moves at a pace typical of mid-size tech companies, though scheduling can slow when you're interviewing with a small, specialized ML team. Push for concrete next-step dates after each round rather than waiting for the recruiter to circle back.

System design is where most candidates underperform, based on the pattern you'd expect given Etsy's unusual catalog. Sketching a generic e-commerce ranking system won't land. Etsy's marketplace is dominated by handmade and vintage items with limited purchase history per listing, so your design needs to address sparse signals, seller-generated descriptions with wildly inconsistent terminology, and seasonal demand spikes around holidays like Christmas and Mother's Day. Grounding your answers in Etsy's published work on LLM-powered query rewriting (covered on their Code as Craft blog) shows you've done real homework on problems this team actually faces.

Etsy Machine Learning Engineer Interview Questions

Ml System Design

Most candidates underestimate how much end-to-end thinking is required to ship ML inside an assistant experience. You’ll need to design data→training→serving→monitoring loops with clear SLAs, safety constraints, and iteration paths.

Design a real-time risk scoring system to block high-risk bookings at checkout within 200 ms p99, using signals like user identity, device fingerprint, payment instrument, listing history, and message content, and include a human review queue for borderline cases. Specify your online feature store strategy, backfills, training-serving skew prevention, and kill-switch rollout plan.

AirbnbMediumReal-time Fraud Scoring Architecture

Sample Answer

Most candidates default to a single supervised classifier fed by a big offline feature table, but that fails here because latency, freshness, and training-serving skew will explode false positives at checkout. You need an online scoring service backed by an online feature store (entity keyed by user, device, payment, listing) with strict TTLs, write-through updates from streaming events, and snapshot consistency via feature versioning. Add a rules layer for hard constraints (sanctions, stolen cards), then route a calibrated probability band to human review with budgeted queue SLAs. Roll out with shadow traffic, per-feature and per-model canaries, and a kill-switch that degrades to rules only when the feature store or model is unhealthy.

A company sees a surge in collusive fake reviews that look benign individually but form dense clusters across guests, hosts, and listings over 30 days, and you must detect it daily while keeping precision above 95% for enforcement actions. Design the end-to-end ML system, including graph construction, model choice, thresholding with uncertainty, investigation tooling, and how you measure success without reliable labels.

AirbnbHardGraph-based Collusion Detection

Sample Answer

Unlock the full solution

View detailed answers and practice in our question bank

View Solution

Practice more Ml System Design questions

Machine Learning & Modeling

Most candidates underestimate how much depth you’ll need on ranking, retrieval, and feature-driven personalization tradeoffs. You’ll be pushed to justify model choices, losses, and offline metrics that map to product outcomes.

What is the bias-variance tradeoff?

EasyFundamentals

Sample Answer

Bias is error from oversimplifying the model (underfitting) — a linear model trying to capture a nonlinear relationship. Variance is error from the model being too sensitive to training data (overfitting) — a deep decision tree that memorizes noise. The tradeoff: as you increase model complexity, bias decreases but variance increases. The goal is to find the sweet spot where total error (bias squared + variance + irreducible noise) is minimized. Regularization (L1, L2, dropout), cross-validation, and ensemble methods (bagging reduces variance, boosting reduces bias) are practical tools for managing this tradeoff.

You are launching a real-time model that flags risky guest bookings to route to manual review, with a review capacity of 1,000 bookings per day and a false negative cost 20 times a false positive cost. Would you select thresholds using calibrated probabilities with an expected cost objective, or optimize for a ranking metric like PR AUC and then pick a cutoff, and why?

AirbnbMediumMetrics and Thresholding

Sample Answer

You could do calibrated probabilities with an explicit expected cost objective, or you could optimize PR AUC and then choose a cutoff. Calibration plus expected cost wins here because you have hard capacity and asymmetric costs, so you want a threshold tied to $\mathbb{E}[\text{cost} \mid p]$ and stable decision-making under drift. PR AUC is still useful for comparing rankers offline, but it does not directly tell you what cutoff minimizes cost at 1,000 reviews per day. If you cannot trust calibration, you fix that first (Platt, isotonic, or calibration under stratified sampling), then threshold by cost and capacity.

After deploying a fraud model for new host listings, you notice a 30% drop in precision at the same review volume, but offline AUC on the last 7 days looks unchanged. Walk through how you would determine whether this is threshold drift, label delay, feature leakage, or adversarial adaptation, and what you would instrument next.

AirbnbHardDebugging and Drift in Adversarial Domains

Sample Answer

Reason through it: Start by checking whether you are actually holding review volume constant at the same score threshold or at the same percentile, those are different under score distribution shift. Next, account for label delay, fraud labels are often right-censored, so compare precision using a fixed maturity window $T$ (for example, only decisions older than $T$ days) and look at recall proxies that do not require final labels. Then test for leakage by verifying that no post-decision signals (refunds, removals, support contacts) entered the online features, and compare training feature timestamps to serving timestamps to catch skew. Finally, probe adversarial adaptation by slicing on entry points (new device, new payment instrument, referral channel), checking for sudden changes in top features and SHAP rank, and adding canary rules or a shadow model to measure behavior shifts before retraining.

Practice more Machine Learning & Modeling questions

Deep Learning

You are training a two-tower retrieval model for the company Search using in-batch negatives, but click-through on tail queries drops while head queries improve. What are two concrete changes you would make to the loss or sampling (not just "more data"), and how would you validate each change offline and online?

AmazonMediumRecSys Retrieval, Negative Sampling

Sample Answer

Reason through it: Tail queries often have fewer true positives and more ambiguous negatives, so in-batch negatives are likely to include false negatives and over-penalize semantically close items. You can reduce false-negative damage by using a softer objective, for example sampled softmax with temperature or a margin-based contrastive loss that stops pushing already-close negatives, or by filtering negatives via category or semantic similarity thresholds. You can change sampling to mix easy and hard negatives, or add query-aware mined negatives while down-weighting near-duplicates to avoid teaching the model that substitutes are wrong. Validate offline by slicing recall@$k$ and NDCG@$k$ by query frequency deciles and by measuring embedding anisotropy and collision rates, then online via an A/B that tracks tail-query CTR, add-to-cart, and reformulation rate, not just overall CTR.

You deploy a ViT-based product image encoder for a cross-modal retrieval system (image to title) and observe training instability when you increase image resolution and batch size on the same GPU budget. Explain the most likely causes in terms of optimization and architecture, and give a prioritized mitigation plan with tradeoffs for latency and accuracy.

AmazonHardComputer Vision, Transformers Optimization

Sample Answer

Unlock the full solution

View detailed answers and practice in our question bank

View Solution

Practice more Deep Learning questions

Coding & Algorithms

Expect questions that force you to translate ambiguous requirements into clean, efficient code under time pressure. Candidates often stumble by optimizing too early or missing edge cases and complexity tradeoffs.

A company Trust flags an account when it has at least $k$ distinct failed payment attempts within any rolling window of $w$ minutes (timestamps are integer minutes, unsorted, may repeat). Given a list of timestamps, return the earliest minute when the flag would trigger, or -1 if it never triggers.

AirbnbMediumSliding Window

Sample Answer

Return the earliest timestamp $t$ such that there exist at least $k$ timestamps in $[t-w+1, t]$, otherwise return -1. Sort the timestamps, then move a left pointer forward whenever the window exceeds $w-1$ minutes. When the window size reaches $k$, the current right timestamp is the earliest trigger because you scan in chronological order and only shrink when the window becomes invalid. Handle duplicates naturally since each attempt counts.

PythonCopy

1from typing import List
2
3
4def earliest_flag_minute(timestamps: List[int], w: int, k: int) -> int:
5    """Return earliest minute when >= k attempts occur within any rolling w-minute window.
6
7    Window definition: for a trigger at minute t (which must be one of the attempt timestamps
8    during the scan), you need at least k timestamps in [t - w + 1, t].
9
10    Args:
11        timestamps: Integer minutes of failed attempts, unsorted, may repeat.
12        w: Window size in minutes, must be positive.
13        k: Threshold count, must be positive.
14
15    Returns:
16        Earliest minute t when the condition is met, else -1.
17    """
18    if k <= 0 or w <= 0:
19        raise ValueError("k and w must be positive")
20    if not timestamps:
21        return -1
22
23    ts = sorted(timestamps)
24    left = 0
25
26    for right, t in enumerate(ts):
27        # Maintain window where ts[right] - ts[left] <= w - 1
28        # Equivalent to ts[left] >= t - (w - 1).
29        while ts[left] < t - (w - 1):
30            left += 1
31
32        if right - left + 1 >= k:
33            return t
34
35    return -1
36
37
38if __name__ == "__main__":
39    # Basic sanity checks
40    assert earliest_flag_minute([10, 1, 2, 3], w=3, k=3) == 3  # [1,2,3]
41    assert earliest_flag_minute([1, 1, 1], w=1, k=3) == 1
42    assert earliest_flag_minute([1, 5, 10], w=3, k=2) == -1
43    assert earliest_flag_minute([2, 3, 4, 10], w=3, k=3) == 4

You maintain a real-time fraud feature for accounts where each event is a tuple (minute, account_id, risk_score); support two operations: update(account_id, delta) that adds delta to the account score, and topK(k) that returns the $k$ highest-scoring account_ids with ties broken by smaller account_id. Implement this with good asymptotic performance under many updates.

AirbnbHardHeaps and Lazy Deletion

Sample Answer

Unlock the full solution

View detailed answers and practice in our question bank

View Solution

Practice more Coding & Algorithms questions

Engineering

Your ability to reason about maintainable, testable code is a core differentiator for this role. Interviewers will probe design choices, packaging, APIs, code review standards, and how you prevent regressions with testing and documentation.

You are building a reusable Python library used by multiple the company teams to generate graph features and call a scoring service, and you need to expose a stable API while internals evolve. What semantic versioning rules and test suite structure do you use, and how do you prevent dependency drift across teams in CI?

PfizerMediumAPI Design and Dependency Management

Sample Answer

Start with what the interviewer is really testing: "This question is checking whether you can keep a shared ML codebase stable under change, without breaking downstream pipelines." Use semantic versioning where breaking changes require a major bump, additive backward-compatible changes are minor, and patches are bug fixes, then enforce it with changelog discipline and deprecation windows. Structure tests as unit tests for pure transforms, contract tests for public functions and schemas, and integration tests that spin up a minimal service stub to ensure client compatibility. Prevent dependency drift by pinning direct dependencies, using lock files, running CI against a small compatibility matrix (Python and key libs), and failing builds on unreviewed transitive updates.

A candidate-generation service for Marketplace integrity uses a shared library to compute features, and after a library update you see a 0.7% drop in precision at fixed recall while offline metrics look unchanged. How do you debug and harden the system so this class of regressions cannot ship again?

MetaHardProduction Debugging and Reliability

Sample Answer

Unlock the full solution

View detailed answers and practice in our question bank

View Solution

Practice more Engineering questions

Ml Operations

The bar here isn’t whether you know MLOps buzzwords, it’s whether you can operate models safely at scale. You’ll discuss monitoring (metrics/logs/traces), drift detection, rollback strategies, and incident-style debugging.

A new graph-based account-takeover model is deployed as a microservice and p99 latency jumps from 60 ms to 250 ms, causing checkout timeouts in some regions. How do you triage and what production changes do you make to restore reliability without losing too much fraud catch?

AirbnbMediumIncident Response and Latency SLOs

Sample Answer

Get this wrong in production and you either tank conversion with timeouts or let attackers through during rollback churn. The right call is to treat latency as an SLO breach, immediately shed load with a circuit breaker (fallback to a simpler model or cached decision), then root-cause with region-level traces (model compute, feature fetch, network). After stabilization, you cap tail latency with timeouts, async enrichment, feature caching, and a two-stage ranker where a cheap model gates expensive graph inference.

You need reproducible training and serving for a fraud model using a petabyte-scale feature store and streaming updates, and you discover training uses daily snapshots while serving uses latest values. What design and tests do you add to eliminate training serving skew while keeping the model fresh?

AirbnbHardReproducibility and Training Serving Skew

Sample Answer

Unlock the full solution

View detailed answers and practice in our question bank

View Solution

Practice more Ml Operations questions

LLMs, RAG & Applied AI

In modern applied roles, you’ll often be pushed to explain how you’d use (or not use) an LLM safely and cost-effectively. You may be asked about RAG, prompt/response evaluation, hallucination mitigation, and when fine-tuning beats retrieval.

What is RAG (Retrieval-Augmented Generation) and when would you use it over fine-tuning?

EasyFundamentals

Sample Answer

RAG combines a retrieval system (like a vector database) with an LLM: first retrieve relevant documents, then pass them as context to the LLM to generate an answer. Use RAG when: (1) the knowledge base changes frequently, (2) you need citations and traceability, (3) the corpus is too large to fit in the model's context window. Use fine-tuning instead when you need the model to learn a new style, format, or domain-specific reasoning pattern that can't be conveyed through retrieved context alone. RAG is generally cheaper, faster to set up, and easier to update than fine-tuning, which is why it's the default choice for most enterprise knowledge-base applications.

You are building an LLM-based case triage service for Trust Operations that reads a ticket (guest complaint, host messages, reservation metadata) and outputs one of 12 routing labels plus a short rationale. What offline and online evaluation plan do you ship with, including how you estimate the cost of false negatives vs false positives and how you detect hallucinated rationales?

AirbnbMediumLLM Evaluation and Guardrails

Sample Answer

This question is checking whether you can turn an LLM feature into an accountable decision system with measurable risk. You should propose an offline set with gold labels, stratified by market and severity, then report macro F1 plus a cost-weighted metric like $\sum_i c_{y_i,\hat{y}_i}$ where costs reflect escalation burden and user harm. For hallucinations, add groundedness checks, for example citation to allowed fields and a verifier model that flags rationales containing entities not present in the input. Online, run an A/B with guardrails on high severity tickets, track resolution time, recontact rate, and downstream incident rate, and use canary slicing to catch regressions by language and region.

Design an agentic copilot for Trust Ops that, for a suspicious booking, retrieves past incidents, runs policy checks, drafts an enforcement action, and writes an audit log for regulators. How do you prevent prompt injection from user messages, limit tool abuse, and decide between prompting, RAG, and fine-tuning when policies change weekly?

AirbnbHardAgent Design, Safety, and Prompting vs RAG vs Fine-tuning

Sample Answer

Unlock the full solution

View detailed answers and practice in our question bank

View Solution

Practice more LLMs, RAG & Applied AI questions

Cloud Infrastructure

A the company client wants an LLM powered Q&A app, embeddings live in a vector DB, and the app runs on AWS with strict data residency and $p95$ latency under $300\,\mathrm{ms}$. How do you decide between serverless (Lambda) versus containers (ECS or EKS) for the model gateway, and what do you instrument to prove you are meeting the SLO?

Boston Consulting Group (BCG)MediumServerless vs Containers for ML APIs

Sample Answer

The standard move is containers for steady traffic, predictable tail latency, and easier connection management to the vector DB. But here, cold start behavior, VPC networking overhead, and concurrency limits matter because they directly hit $p95$ and can violate residency if you accidentally cross regions. You should instrument request traces end to end, tokenization and model time, vector DB latency, queueing, and regional routing, then set alerts on $p95$ and error budgets.

A cheating detection model runs as a gRPC service on Kubernetes with GPU nodes, it must survive node preemption and a sudden $10\times$ traffic spike after a patch, while keeping $99.9\%$ monthly availability. Design the deployment strategy (autoscaling, rollout, and multi-zone behavior), and call out two failure modes you would monitor for at the cluster and pod level.

Blizzard EntertainmentHardKubernetes scaling, rollouts, and resiliency

Sample Answer

Unlock the full solution

View detailed answers and practice in our question bank

View Solution

Practice more Cloud Infrastructure questions

The balanced distribution masks a compounding challenge unique to Etsy: system design questions here demand you reason about a catalog where most items are one-of-a-kind, seller descriptions use inconsistent craft terminology, and inventory vanishes after a single sale. That means your ML fundamentals prep and your design prep aren't separate workstreams. You need to explain, say, why a particular embedding approach handles Etsy's long-tail query language (the same query rewriting problems their Code as Craft blog documents) while simultaneously defending the business tradeoff for buyer conversion versus seller fairness. The prep mistake that burns candidates most often is drilling generic marketplace system design without studying how Etsy's handmade, low-inventory constraints break standard e-commerce patterns like collaborative filtering on repeat purchases.

For more ML interview questions tailored to roles like this, check out datainterview.com/questions.

How to Prepare for Etsy Machine Learning Engineer Interviews

Etsy reported $2.88B in revenue with 3.5% year-over-year growth, while headcount dipped slightly to 2,375. One of the most visible ML investments is using LLMs to rewrite and interpret search queries for a catalog dominated by one-of-a-kind items with seller-written descriptions that follow no standard taxonomy.

That search problem shapes what ML engineers actually do here. When a buyer types "cottagecore kitchen stuff" and the matching listing says "rustic farmhouse wooden spoon set," the model has to bridge a vocabulary gap that product-ID-based retrieval can't touch. Cold-start and sparse-signal ranking are far more acute on Etsy than on marketplaces with standardized SKUs and repeat-purchase data, which makes query understanding and embedding-based retrieval the daily bread of the ML team.

Show you understand those technical constraints, not just the mission, when you answer "why Etsy." Reference how Etsy's product delivery culture gives ML engineers ownership over buyer outcomes, not just offline metrics. Mention their customer-focused approach to internal tooling, which signals that building reusable infrastructure for model iteration is valued alongside shipping models themselves.

Connecting your experience to Etsy's specific catalog quirks (seasonal demand spikes around holidays, inconsistent seller terminology, items that sell once and disappear) is what separates a compelling answer from a generic one about supporting small business.

Try a Real Interview Question

1from typing import Sequence
2
3
4def expected_calibration_error(probs: Sequence[float], labels: Sequence[int], num_bins: int) -> float:
5    """Compute expected calibration error (ECE) using equal-width probability bins.
6
7    Args:
8        probs: Sequence of predicted probabilities in [0, 1].
9        labels: Sequence of 0/1 labels, same length as probs.
10        num_bins: Number of equal-width bins partitioning [0, 1].
11
12    Returns:
13        The expected calibration error as a float.
14    """
15    pass
16

1from typing import Sequence
2
3
4def expected_calibration_error(probs: Sequence[float], labels: Sequence[int], num_bins: int) -> float:
5    """Compute expected calibration error (ECE) using equal-width probability bins.
6
7    Bins are [0, 1/num_bins), [1/num_bins, 2/num_bins), ..., [(B-1)/B, 1],
8    with 1.0 included in the last bin.
9
10    Args:
11        probs: Sequence of predicted probabilities in [0, 1].
12        labels: Sequence of 0/1 labels, same length as probs.
13        num_bins: Number of equal-width bins partitioning [0, 1].
14
15    Returns:
16        The expected calibration error as a float.
17
18    Raises:
19        ValueError: If inputs are invalid.
20    """
21    if num_bins <= 0:
22        raise ValueError("num_bins must be positive")
23    if len(probs) != len(labels):
24        raise ValueError("probs and labels must have the same length")
25
26    n = len(probs)
27    if n == 0:
28        return 0.0
29
30    counts = [0] * num_bins
31    sum_p = [0.0] * num_bins
32    sum_y = [0.0] * num_bins
33
34    for p, y in zip(probs, labels):
35        if not (0.0 <= p <= 1.0):
36            raise ValueError("probabilities must be in [0, 1]")
37        if y not in (0, 1):
38            raise ValueError("labels must be 0 or 1")
39
40        idx = int(p * num_bins)
41        if idx == num_bins:
42            idx = num_bins - 1
43
44        counts[idx] += 1
45        sum_p[idx] += float(p)
46        sum_y[idx] += float(y)
47
48    ece = 0.0
49    for b in range(num_bins):
50        c = counts[b]
51        if c == 0:
52            continue
53        conf = sum_p[b] / c
54        acc = sum_y[b] / c
55        ece += (c / n) * abs(acc - conf)
56
57    return float(ece)
58

Etsy's search and ranking stack runs on Python services within GCP, so their coding rounds favor problems where you manipulate real-world data structures and build feature pipelines rather than optimize obscure graph traversals. Sharpen that muscle at datainterview.com/coding.

Test Your Readiness

Quiz yourself on query rewriting, cold-start ranking strategies, and the evaluation tradeoffs that come up when items rarely get repeat purchases at datainterview.com/questions.