Uber·Software Engineer·Onsite - System Design / Architecture·Senior

Senior

Jul 2026

Summary

System design round at Uber for a software engineering role. The prompt was designing the shopping cart for Uber Eats, which sounds contained until you actually start pulling on the threads.

Questions Asked (1)

Design the shopping cart system for Uber Eats. Walk through the architecture end to end.

System DesignData ModelingTechnical Trade-offs

Author's notes

Spent probably too long on the data model upfront and had to rush the concurrency stuff later, which is honestly where the interesting problems live.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scope (e.g., single restaurant vs. multi-restaurant carts, real-time menu updates, promotions). Then design a scalable, eventually consistent architecture that separates cart service from menu and order services, using a data model that supports item customization and pricing. Walk through the end-to-end flow from cart creation to checkout, highlighting trade-offs and failure handling.

Pro tip: Emphasize idempotency and consistency: carts are mutable and user-facing, so use optimistic concurrency control and idempotent operations to handle duplicate requests and race conditions. Also, discuss how to handle menu changes (e.g., item unavailable) gracefully without breaking the cart.

1. Clarify Requirements and Scope

Ask questions to define functional and non-functional requirements: single vs. multi-restaurant carts, guest vs. logged-in users, real-time menu updates, promotions, and scale (e.g., millions of users). Establish constraints like latency, consistency, and availability.

2. High-Level Architecture

Sketch the main components: API Gateway, Cart Service, Menu Service, Pricing/Promotions Service, Order Service, and data stores (e.g., NoSQL for carts, cache for menus). Explain how they interact and the overall data flow.

3. Data Model and Storage

Design the cart data model: cart ID, user ID, restaurant ID, items (with customizations, quantity, price), status, timestamps. Choose a storage solution (e.g., DynamoDB, Cassandra) that supports high write throughput and eventual consistency, and discuss caching strategies.

4. End-to-End Flow and API Design

Walk through key operations: add/remove/update item, apply promo, checkout. Define RESTful or gRPC APIs, and describe how the Cart Service validates items against the Menu Service, calculates totals with the Pricing Service, and hands off to the Order Service.

5. Trade-offs, Scalability, and Failure Handling

Discuss trade-offs: consistency vs. availability, synchronous vs. asynchronous validation, and handling menu changes (e.g., item becomes unavailable). Cover scalability (sharding by user ID), idempotency, retries, and graceful degradation.

Key Points to Mention

Idempotency and optimistic concurrency control to handle duplicate requests and concurrent cart modifications.
Eventual consistency for cart data, with caching for menu items to reduce latency and load on Menu Service.
Handling menu changes: when an item becomes unavailable or price changes, how to notify the user and update the cart.
Sharding strategy for cart storage (e.g., by user ID) to ensure scalability and even distribution.
Integration with promotions/pricing service to compute discounts and taxes in real-time.
Failure scenarios: what happens if Menu Service is down during checkout, and how to ensure order integrity.

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