← eBay Interview Insights

eBay·Backend Engineer·Onsite - System Design / Architecture·Senior

SeniorPrefer not to say
May 2026

Summary

eBay system design round focused entirely on food delivery backend at scale. The whole session was basically one big question broken into sub-problems, and the surge handling part took way longer than I expected.

Questions Asked (8)

Q1

Design the order placement and restaurant routing flow for a food delivery app.

System DesignTechnical Trade-offs
Author's notes

Started with the happy path and the interviewer seemed fine with that.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying functional and non-functional requirements, then design the high-level architecture for order placement and restaurant routing, focusing on scalability, consistency, and fault tolerance. Dive into key components like order service, restaurant matching, and routing algorithms, discussing trade-offs between consistency and availability, and between different routing strategies.

Pro tip: Emphasize idempotency and exactly-once processing for order placement to handle retries and avoid duplicate orders, and discuss how to handle restaurant unavailability or rejection gracefully with fallback mechanisms.

1. Clarify Requirements

Ask questions to understand expected scale, latency requirements, consistency needs, and key features like order tracking and restaurant selection criteria.

2. High-Level Design

Outline the main components: API gateway, order service, restaurant service, routing service, and databases. Explain how they interact for order placement and routing.

3. Deep Dive into Order Placement

Detail the order placement flow: validation, payment authorization, order persistence, and idempotency. Discuss consistency models and failure handling.

4. Deep Dive into Restaurant Routing

Explain how to select and route orders to restaurants: matching algorithms (e.g., proximity, availability, load), routing logic, and handling restaurant responses (accept/reject/timeout).

5. Address Trade-offs and Scalability

Discuss trade-offs: SQL vs NoSQL, synchronous vs asynchronous processing, consistency vs availability. Explain scaling strategies like sharding, caching, and message queues.

Key Points to Mention

  • Idempotency and exactly-once semantics for order placement to handle retries and avoid duplicates.
  • Use of message queues (e.g., Kafka) for asynchronous communication between services, enabling decoupling and fault tolerance.
  • Database choices: SQL for transactional order data, NoSQL for high-throughput restaurant availability and location data.
  • Routing algorithms: geospatial indexing (e.g., geohash) for proximity search, load balancing across restaurants, and fallback strategies.
  • Consistency models: strong consistency for order state, eventual consistency for restaurant availability and routing decisions.
  • Handling failures: timeouts, retries with exponential backoff, circuit breakers, and compensation transactions (Sagas) for distributed transactions.

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

Q2

How would you handle courier matching in real time at scale?

System DesignAlgorithms & Data Structures
Author's notes

Went with a geospatial index approach, talked about radius queries and scoring couriers by proximity plus current load.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements and constraints (e.g., scale, latency, courier availability, delivery types). Then propose a high-level architecture that includes real-time location tracking, a matching algorithm (e.g., geospatial indexing + scoring), and a dispatch system. Discuss trade-offs and how you would handle scale, failures, and optimization.

Pro tip: Emphasize the importance of defining clear matching criteria (e.g., distance, courier rating, current load) and using a feedback loop to continuously improve the algorithm. Also, mention the need for idempotency and exactly-once processing to avoid duplicate assignments.

1. Clarify Requirements

Ask questions to understand scale (e.g., number of couriers, orders per second), latency requirements, and matching constraints (e.g., max distance, courier capacity).

2. High-Level Architecture

Outline components: real-time location ingestion (e.g., via Kafka), geospatial index (e.g., Redis GEO or Elasticsearch), matching service, and dispatch/notification system.

3. Matching Algorithm

Describe how to find nearby couriers using geospatial queries, then rank them using a scoring function (e.g., distance, rating, current load). Consider using a greedy approach or more sophisticated algorithms like bipartite matching.

4. Scalability and Reliability

Discuss partitioning (e.g., by region), caching, load balancing, and handling failures (e.g., retries, fallbacks). Mention consistency models and idempotency.

5. Optimization and Monitoring

Talk about metrics (e.g., match rate, latency), A/B testing, and iterative improvements. Consider edge cases like courier going offline or order cancellation.

Key Points to Mention

  • Geospatial indexing (e.g., Geohash, Quadtree, Redis GEO) for efficient proximity search
  • Real-time data pipeline (e.g., Kafka, Flink) for location updates and order events
  • Scoring and ranking algorithm (e.g., weighted sum of distance, rating, load)
  • Partitioning and sharding strategies to scale horizontally
  • Idempotency and exactly-once semantics to prevent duplicate assignments
  • Monitoring and feedback loops for continuous improvement

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

Q3

Walk me through how you'd architect real-time order tracking for customers.

System DesignAPI & Integrations
Author's notes

WebSockets or SSE, location updates from couriers on a short polling interval pushed through a pub/sub layer.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements (scale, latency, consistency, data sources) and then propose a high-level architecture that decouples event ingestion from customer-facing APIs. Focus on real-time event streaming, scalable storage, and push-based updates to clients, while addressing reliability and cost trade-offs.

Pro tip: Emphasize idempotency and exactly-once processing for order events, and discuss how you'd handle late or out-of-order events to maintain a consistent tracking view.

1. Clarify Requirements

Ask about expected scale (orders/sec, concurrent users), latency needs (sub-second vs. seconds), data sources (carriers, warehouses), and consistency requirements (eventual vs. strong).

2. High-Level Architecture

Outline components: event ingestion (Kafka), stream processing (Flink/Spark), storage (Cassandra/DynamoDB for current state, Redis for cache), and API layer (WebSocket/SSE for push, REST for pull).

3. Data Flow & Processing

Describe how events flow from sources to ingestion, are processed (enrichment, deduplication, ordering), and written to storage; then how updates are pushed to clients via pub/sub.

4. Scalability & Reliability

Explain partitioning, replication, backpressure, and fault tolerance; discuss idempotency, exactly-once semantics, and handling late/out-of-order events.

5. Trade-offs & Optimizations

Discuss trade-offs (latency vs. consistency, cost vs. performance) and optimizations like caching, batching, and CDN for static assets.

Key Points to Mention

  • Event-driven architecture with Kafka for ingestion and stream processing
  • WebSocket or Server-Sent Events (SSE) for real-time push to clients
  • Data storage choices: NoSQL for scalability, Redis for low-latency reads
  • Idempotency and exactly-once processing to avoid duplicate updates
  • Handling late/out-of-order events with watermarks or event-time processing
  • Scalability via partitioning, replication, and horizontal scaling

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

Q4

How do you design the system to handle peak-hour order spikes without degrading the experience?

System DesignTechnical Trade-offs
Author's notes

This is where the session got intense.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the scale and requirements, then propose a multi-layered architecture that combines horizontal scaling, caching, asynchronous processing, and graceful degradation. Emphasize trade-offs between consistency, latency, and cost, and explain how each component contributes to maintaining a seamless user experience during peak loads.

Pro tip: Quantify the impact of your design choices—e.g., 'This reduces p99 latency by X%'—and mention how you'd validate the system with load testing and chaos engineering. Also, highlight eBay-specific considerations like auction sniping and high-value transactions.

1. Clarify Requirements and Scale

Ask questions to understand expected peak traffic (e.g., orders per second), latency SLAs, consistency needs, and budget constraints. This ensures your design targets the right problem.

2. Design for Horizontal Scalability

Propose stateless services, sharding, and auto-scaling groups to handle increased load. Use load balancers to distribute traffic and ensure no single point of failure.

3. Implement Caching and Asynchronous Processing

Introduce multi-level caching (CDN, Redis) for read-heavy paths and message queues (Kafka) to decouple order processing from user-facing requests, smoothing spikes.

4. Ensure Graceful Degradation and Resilience

Design fallbacks like circuit breakers, rate limiting, and priority queues to maintain core functionality under extreme load. Use backpressure to avoid cascading failures.

5. Monitor, Test, and Iterate

Define key metrics (throughput, latency, error rates) and set up real-time monitoring. Conduct load tests and game days to validate the design and identify bottlenecks.

Key Points to Mention

  • Horizontal scaling with stateless services and auto-scaling
  • Caching strategies (CDN, Redis) and cache invalidation
  • Asynchronous processing with message queues (e.g., Kafka) for order placement
  • Database sharding and read replicas to handle write/read spikes
  • Rate limiting, circuit breakers, and graceful degradation
  • Load testing and chaos engineering for validation

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

Q5

How would you implement dynamic pricing during surge periods, and what are the trade-offs?

Pricing & MonetizationTechnical Trade-offsA/B Testing & Experimentation
Author's notes

Talked about a demand signal computed from queue depth and courier availability ratio, feeding into a pricing multiplier with a cap.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the business context and goals for dynamic pricing at eBay, then outline a technical architecture that ingests real-time signals (demand, inventory, competitor prices) and applies pricing rules or ML models. Discuss trade-offs like fairness, buyer trust, seller impact, and system complexity, and propose A/B testing to validate pricing strategies.

Pro tip: Emphasize the importance of guardrails and gradual rollouts to avoid alienating buyers or sellers, and mention how you would monitor long-term effects like retention and seller churn, not just short-term revenue.

1. Clarify Requirements and Constraints

Ask about the specific surge scenarios (e.g., high-demand events, limited inventory), business objectives (maximize revenue vs. clear inventory), and any regulatory or fairness constraints.

2. Design the Technical Architecture

Outline a system that collects real-time data (user activity, inventory, competitor prices), processes it with stream processing (e.g., Kafka, Flink), and applies pricing algorithms (rules or ML) to update prices dynamically.

3. Address Trade-offs and Risks

Discuss trade-offs such as potential buyer backlash, seller dissatisfaction, increased system complexity, and the risk of price wars or unintended consequences.

4. Propose Experimentation and Rollout Plan

Suggest A/B testing with control groups, gradual rollout, and key metrics (conversion, revenue, retention) to measure impact and iterate.

5. Define Monitoring and Guardrails

Explain how you would monitor system performance and business metrics, set price floors/ceilings, and implement alerts for anomalies or negative trends.

Key Points to Mention

  • Real-time data ingestion and processing (e.g., Kafka, Flink) for demand signals
  • Pricing algorithms: rule-based vs. machine learning models (e.g., reinforcement learning)
  • A/B testing framework with control groups and statistical significance
  • Trade-offs: buyer trust, seller fairness, system latency, and operational cost
  • Guardrails: price caps/floors, rate limiting, and manual override
  • Long-term metrics: customer retention, seller churn, and brand perception

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

Q6

What strategies would you use to mitigate hot-spot problems, like a single very popular restaurant or a dense urban delivery zone?

System DesignData Modeling
Author's notes

Cell-based sharding for the geographic hot-spot, caching restaurant menus and availability aggressively, and pre-warming capacity for restaurants that historically spike at certain times.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the scenario and requirements, then systematically address hot-spot mitigation across data modeling, caching, sharding, and load balancing. Emphasize trade-offs and monitoring, and tie your answer to eBay's scale and domain (e.g., local commerce, delivery zones).

Pro tip: Mention that hot-spots are often transient and can be handled with adaptive techniques like dynamic request routing and real-time load shedding, rather than only static partitioning. Also, highlight the importance of measuring and detecting hot-spots before they impact users.

1. Clarify requirements and constraints

Ask questions to understand the scale, read/write ratio, latency SLAs, and whether the hot-spot is for reads, writes, or both. This ensures your strategies are relevant and targeted.

2. Identify and detect hot-spots

Discuss monitoring and detection mechanisms, such as per-key request metrics, heat maps, and anomaly detection. Explain how you would know a hot-spot exists and its severity.

3. Apply data modeling and partitioning strategies

Cover techniques like sharding by key with salt, consistent hashing, and splitting hot keys into sub-keys. For read-heavy hot-spots, consider caching and read replicas; for write-heavy, consider write-behind queues or aggregation.

4. Implement dynamic load management

Describe adaptive approaches like request routing to less loaded replicas, rate limiting, load shedding, and autoscaling. Mention the role of a load balancer or API gateway in distributing traffic.

5. Evaluate trade-offs and iterate

Discuss the trade-offs of each strategy (e.g., consistency vs. availability, complexity vs. benefit) and how you would measure effectiveness and iterate. Emphasize a feedback loop with monitoring.

Key Points to Mention

  • Sharding and partitioning strategies (e.g., key salting, consistent hashing) to distribute load
  • Caching layers (local, distributed, CDN) and cache invalidation for read hot-spots
  • Asynchronous processing and write aggregation (e.g., queues, batching) for write hot-spots
  • Dynamic request routing and load balancing (e.g., least connections, consistent hashing with bounded loads)
  • Rate limiting, load shedding, and autoscaling to protect the system
  • Monitoring and observability to detect and respond to hot-spots in real-time

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

Q7

How do you ensure reliability when parts of the system fail, specifically around order placement and payments?

System DesignTechnical Trade-offs
Author's notes

Idempotency keys on payment requests, outbox pattern for order events so nothing gets lost if the service crashes mid-write, and saga-style compensation for partial failures.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by framing reliability as a multi-layered concern: prevent failures where possible, detect and isolate them quickly, and recover gracefully with minimal user impact. Then walk through concrete patterns for order placement and payments, such as idempotency, retries with backoff, circuit breakers, and asynchronous processing. Finally, discuss trade-offs between consistency, availability, and latency, showing how you'd choose based on business impact.

Pro tip: Emphasize idempotency and exactly-once semantics for payments—interviewers at eBay care deeply about not double-charging or losing orders. Also mention that you'd measure and monitor failure rates and set SLOs to drive reliability improvements.

1. Clarify requirements and failure modes

Ask about expected scale, consistency needs, and what 'failure' means (e.g., service down, slow, partial failure). Identify critical paths: order placement and payment authorization/capture.

2. Design for prevention and isolation

Use patterns like idempotency keys, circuit breakers, bulkheads, and timeouts to prevent cascading failures. Decouple services with queues and async processing where possible.

3. Implement detection and recovery

Describe monitoring, alerting, and health checks. For recovery, discuss retries with exponential backoff and jitter, dead-letter queues, and compensating transactions (Sagas) for distributed rollback.

4. Ensure data consistency and correctness

Explain how you maintain consistency across services: idempotent operations, transactional outbox, event sourcing, or two-phase commit (with trade-offs). For payments, emphasize exactly-once processing and reconciliation.

5. Discuss trade-offs and validation

Compare consistency vs. availability (CAP), latency vs. durability, and complexity vs. reliability. Mention testing strategies like chaos engineering and load testing to validate resilience.

Key Points to Mention

  • Idempotency keys for order and payment APIs to prevent duplicate operations
  • Retry mechanisms with exponential backoff and jitter, plus circuit breakers to avoid overwhelming downstream services
  • Asynchronous processing and queues (e.g., Kafka, SQS) to decouple order placement from payment processing
  • Saga pattern or compensating transactions for distributed rollback when a step fails
  • Monitoring, alerting, and SLOs to detect and respond to failures quickly
  • Trade-offs between consistency and availability, and how to choose based on business impact

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

Q8

How would you set up observability and define SLOs for this system specifically during surge conditions?

Product Analytics & MetricsSystem Design
Author's notes

Talked about p99 latency on order placement as the primary SLO, queue consumer lag as a leading indicator, and courier match time as a separate SLO.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the system's architecture and what 'surge conditions' mean for this specific system (e.g., traffic spikes, flash sales, seasonal events). Then outline a layered observability strategy covering metrics, logs, and traces, and explain how you would define SLOs that account for surge behavior, including error budgets and burn rates. Finally, describe how you would use these SLOs to drive alerting and capacity planning during surges.

Pro tip: Tie SLOs to user-facing impact and business metrics, not just infrastructure health—eBay cares about conversion and revenue during surges. Also, mention that you would set separate SLOs for surge periods or use adaptive thresholds, since normal SLOs may not be appropriate when traffic is 10x.

1. Clarify system and surge context

Ask clarifying questions about the system's architecture, dependencies, and what constitutes a surge (e.g., expected traffic multiplier, duration, and business impact). This ensures your observability plan is tailored to the specific system.

2. Define observability pillars

Outline the three pillars: metrics (e.g., latency, error rate, throughput, saturation), logs (structured, with correlation IDs), and distributed tracing (to identify bottlenecks across services). Mention tools like Prometheus, Grafana, Jaeger, or eBay's internal equivalents.

3. Identify critical user journeys and SLIs

Map the key user journeys (e.g., search, view item, add to cart, checkout) and define SLIs for each, such as availability, latency, and error rate. Focus on what matters most during surges.

4. Set SLOs and error budgets for surge conditions

Propose SLO targets (e.g., 99.9% availability, p99 latency < 500ms) and explain how they might be adjusted during surges. Define error budgets and burn rates to balance reliability with feature velocity.

5. Implement monitoring, alerting, and response

Describe how you would monitor SLIs against SLOs, set up alerts (e.g., multi-window burn rate alerts), and create runbooks for surge incidents. Include capacity planning and auto-scaling triggers based on observability data.

Key Points to Mention

  • Use of RED method (Rate, Errors, Duration) and USE method (Utilization, Saturation, Errors) for metrics
  • Distributed tracing to pinpoint latency bottlenecks during surges
  • Defining SLIs that reflect user experience (e.g., page load time, successful checkout rate)
  • Setting SLOs with error budgets and burn rates to manage reliability during surges
  • Adaptive or surge-specific SLOs to avoid false alerts during expected traffic spikes
  • Integration with incident management and capacity planning (e.g., auto-scaling based on SLO burn)

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