← Figma Interview Insights

Figma·Machine Learning Engineer·Onsite - System Design / Architecture·Senior

SeniorPrefer not to say
Apr 2026

Summary

ML system design round at Figma for an MLE role. The whole session was one big open-ended question about building a home feed recommendation system from scratch, covering everything from retrieval to serving. Dense but actually pretty interesting if you've done this kind of work before.

Questions Asked (5)

Q1

Design a home feed recommendation system for a large consumer app. Walk through how you'd frame the problem, generate candidates, rank them, and serve the results at scale.

System DesignTechnical Trade-offsProduct Analytics & Metrics
Author's notes

This is basically the canonical ML system design question and I still fumbled parts of it.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the product context and objectives for Figma's home feed, then structure your answer around the classic recommendation pipeline: candidate generation, ranking, and serving. Emphasize scalability, real-time constraints, and evaluation metrics, while tailoring to Figma's collaborative design platform.

Pro tip: Show awareness of Figma's unique data: design file interactions, team collaboration patterns, and community engagement. Highlight how you'd balance relevance with discovery to avoid filter bubbles in a creative tool.

1. Clarify Requirements and Scope

Ask questions to understand the feed's purpose (e.g., discover designs, stay updated on team activity), scale (DAU, items), and constraints (latency, freshness). Define success metrics like engagement, retention, and diversity.

2. Design Candidate Generation

Outline multiple sources: collaborative filtering (similar users/teams), content-based (design similarity), trending/popular, and social graph (follows, team activity). Discuss trade-offs between recall and computational cost.

3. Build Ranking Models

Propose a multi-stage ranking system: lightweight model for initial filtering, then a heavier model (e.g., deep learning) for final ranking. Features should include user-item interactions, recency, and contextual signals.

4. Address Serving and Scalability

Explain architecture: precompute candidates offline, use a feature store for real-time features, and serve via a low-latency API. Discuss caching, sharding, and fallback strategies for high availability.

5. Define Evaluation and Iteration

Cover offline metrics (AUC, NDCG), online A/B tests, and guardrail metrics (diversity, freshness). Mention feedback loops and how to handle cold start and exploration.

Key Points to Mention

  • Two-tower models for candidate generation and deep ranking models (e.g., DLRM) for ranking.
  • Real-time feature computation and low-latency serving using a feature store (e.g., Feast) and caching.
  • Handling cold start with content-based features and exploration strategies like epsilon-greedy.
  • Evaluation metrics: offline (recall@k, NDCG) and online (CTR, dwell time, retention).
  • Scalability considerations: sharding, load balancing, and precomputation vs. on-the-fly.
  • Figma-specific signals: design file views, comments, team collaborations, and community likes.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q2

How would you handle candidate generation at scale? What retrieval approaches would you consider and what are the tradeoffs?

System DesignTechnical Trade-offsAlgorithms & Data Structures
Author's notes

Talked through collaborative filtering versus two-tower models.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the scale, latency, and quality requirements, then propose a multi-stage retrieval pipeline (e.g., candidate generation, ranking, re-ranking). Discuss specific retrieval approaches like ANN, inverted indexes, and embedding-based methods, and analyze tradeoffs in terms of recall, latency, cost, and complexity.

Pro tip: Emphasize that candidate generation is about maximizing recall within a latency budget, and that the choice of retrieval method should be driven by the data modality and query patterns—Figma's design data likely requires handling both structured and unstructured signals.

1. Clarify Requirements and Constraints

Ask about scale (QPS, corpus size), latency SLAs, quality metrics (recall@k), and infrastructure constraints. This ensures your solution is tailored to Figma's needs.

2. Outline a Multi-Stage Retrieval Pipeline

Describe a typical pipeline: candidate generation (retrieve hundreds), ranking (score and sort), and re-ranking (business rules). Explain why candidate generation is critical for recall.

3. Discuss Retrieval Approaches and Tradeoffs

Compare methods like inverted indexes (BM25), ANN (HNSW, IVF), and embedding-based retrieval. For each, cover tradeoffs: recall vs. latency, memory vs. accuracy, and ease of updates.

4. Address Scalability and Productionization

Explain how to scale: sharding, distributed indexes, caching, and incremental updates. Mention monitoring recall and latency in production.

5. Conclude with a Recommendation

Summarize a recommended approach for Figma, such as a hybrid of lexical and semantic retrieval, and justify it based on the tradeoffs discussed.

Key Points to Mention

  • Tradeoffs between exact vs. approximate nearest neighbor search (e.g., recall vs. latency)
  • Hybrid retrieval combining lexical (BM25) and semantic (embeddings) signals
  • Indexing structures: inverted index, HNSW, IVF, and their memory/latency characteristics
  • Handling multi-modal data (e.g., text, images, design files) with separate or joint embeddings
  • Latency budget and how to meet it via caching, sharding, and early termination
  • Evaluation metrics: recall@k, latency percentiles, and online A/B testing

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q3

How would you structure the ranking model, and how do you handle real-time versus batch features in that pipeline?

System DesignData ModelingTechnical Trade-offs
Author's notes

Feature store question dressed up as a ranking question.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the ranking objective and the specific Figma use case (e.g., ranking templates, community content, or search results). Then describe a two-stage architecture (candidate generation + ranking) and explain how you would handle real-time and batch features using a feature store, with trade-offs around latency, freshness, and complexity.

Pro tip: Emphasize the importance of feature consistency between training and serving, and mention how you would monitor and mitigate training-serving skew. Also, discuss the trade-off between model complexity and inference latency, especially for real-time ranking.

1. Clarify requirements and constraints

Ask about the ranking objective (e.g., engagement, relevance), scale (QPS, latency), and data availability. Understand Figma's specific context, such as ranking design templates or community files.

2. Design the ranking model architecture

Propose a multi-stage pipeline: candidate generation (e.g., ANN, collaborative filtering) followed by a ranking model (e.g., GBDT, DNN). Explain how the model uses features and the trade-offs between model complexity and latency.

3. Handle real-time vs batch features

Describe a feature store that serves both batch (precomputed) and real-time (streaming) features. Explain how batch features are updated periodically (e.g., daily) and real-time features are computed on the fly (e.g., user interactions).

4. Address training-serving consistency and latency

Discuss how to ensure features used in training match those at serving time, using techniques like point-in-time correctness and logging. Also, cover latency optimization for real-time features (e.g., caching, approximate computations).

5. Evaluate and iterate

Outline offline evaluation (A/B testing, metrics like NDCG) and online monitoring (click-through rate, latency). Mention how to handle feedback loops and retrain models periodically.

Key Points to Mention

  • Two-stage ranking: candidate generation and ranking model
  • Feature store for consistency between batch and real-time features
  • Trade-offs: latency vs freshness, model complexity vs inference speed
  • Training-serving skew and point-in-time correctness
  • Real-time feature computation: streaming (e.g., Kafka, Flink) and caching
  • Evaluation metrics: offline (NDCG, MAP) and online (CTR, engagement)

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q4

Once you have ranked results, how do you re-rank them before serving? What factors beyond the model score matter?

System DesignA/B Testing & ExperimentationProduct Strategy
Author's notes

This is where I actually felt most comfortable.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the context: re-ranking is a post-processing step after initial retrieval/ranking, often using a more expensive model or business rules. Then describe a multi-stage re-ranking pipeline that incorporates additional signals beyond the model score, such as user context, business rules, and diversity. Finally, emphasize the importance of experimentation and metrics to validate the re-ranking strategy.

Pro tip: At Figma, where design collaboration and community content are key, re-ranking should balance relevance with diversity and freshness to avoid filter bubbles and promote discovery. Also, consider latency constraints: re-ranking must be fast enough for real-time serving, so precompute or cache where possible.

1. Clarify the re-ranking stage

Explain that re-ranking occurs after an initial ranking (e.g., from a retrieval model) and before serving. It can involve a second model, business rules, or a combination.

2. Incorporate additional signals

List factors beyond model score: user context (device, location, history), item attributes (freshness, popularity, quality), business rules (promotions, diversity, fairness), and system constraints (latency, load).

3. Design the re-ranking mechanism

Describe how to combine signals: e.g., weighted sum, learning-to-rank with features, or rule-based filters. Mention trade-offs between complexity and latency.

4. Evaluate and iterate

Emphasize A/B testing to measure impact on key metrics (CTR, engagement, satisfaction). Use offline metrics (NDCG, MRR) for initial validation.

5. Monitor and adapt

Discuss monitoring for drift, feedback loops, and the need to periodically retrain or adjust re-ranking rules based on performance.

Key Points to Mention

  • Multi-stage ranking: retrieval -> ranking -> re-ranking
  • User context and personalization signals
  • Business rules: diversity, freshness, fairness, promotions
  • Latency and system constraints in real-time serving
  • A/B testing and online metrics for validation
  • Feedback loops and long-term effects (e.g., filter bubbles)

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q5

How would you set up the serving infrastructure and measure whether the system is actually working in production?

System DesignA/B Testing & ExperimentationProduct Analytics & Metrics
Author's notes

Latency budget across the retrieval, ranking, and re-ranking pipeline was straightforward.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the ML use case and production constraints (latency, scale, cost), then outline a serving architecture (e.g., model server, feature store, caching, monitoring) and define a measurement strategy that combines technical metrics (latency, error rates) with product metrics (engagement, conversion) via A/B testing. Emphasize iterative improvement and guardrail metrics to ensure the system works as intended.

Pro tip: Tie every metric to a business outcome and explicitly call out trade-offs (e.g., latency vs. accuracy) to show you think like a product-minded engineer, not just a model builder.

1. Clarify requirements and constraints

Ask about the ML task, expected traffic, latency SLAs, and integration points with existing systems. This ensures your design is grounded in real needs.

2. Design serving infrastructure

Propose a scalable serving stack: model server (e.g., TensorFlow Serving, TorchServe), feature store for consistent features, caching for repeated requests, and load balancing. Discuss deployment patterns (canary, shadow) and fallback mechanisms.

3. Define technical and product metrics

Select technical metrics (latency p99, error rate, throughput) and product metrics (CTR, conversion, task success) that reflect system health and user impact. Include guardrail metrics to catch regressions.

4. Set up experimentation and monitoring

Plan an A/B test with proper randomization, sample size, and duration. Implement logging, dashboards, and alerts for real-time monitoring. Use statistical tests to measure significance.

5. Iterate and validate

Analyze results, check for novelty effects, and decide whether to launch, iterate, or rollback. Continuously monitor post-launch to ensure sustained performance.

Key Points to Mention

  • Model serving frameworks (TensorFlow Serving, TorchServe, ONNX Runtime) and their trade-offs
  • Feature store for online/offline consistency (e.g., Feast, Tecton)
  • A/B testing best practices: randomization unit, sample size calculation, statistical significance
  • Monitoring tools (Prometheus, Grafana) and alerting for model drift and data quality
  • Guardrail metrics to prevent negative user impact
  • Canary deployment and shadow mode for safe rollout

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.