Scenario

Design the backend service for a cart management lifecycle within an on-demand delivery application (e.g., for restaurants and groceries). Users should be able to create a cart, modify its contents from multiple devices simultaneously, and then proceed to checkout, which converts the cart into a fulfillable order.

This prompt is intentionally vague. Candidates are expected to drive the requirements, scope, and assumptions through clarifying questions.

Core Workflow (Cart Lifecycle)

1. Create Cart: A user initiates a new shopping cart.
2. Modify Items: Users can add, remove, or update the quantity and selected options (e.g., size, toppings) of items within their cart.
3. View Cart: Users can view the current contents and details of their active cart.
4. Checkout: The active cart is converted into an order, which requires strong correctness guarantees.
5. Order Fulfillment: The created order proceeds to the fulfillment process.
6. Cart Closure/Expiration: A cart closes after successful checkout or expires if abandoned.

Functional Requirements

• Cart Creation: Create an active cart associated with a specific user and a merchant/store.
• Mutations:
  • Add item to cart.
  • Remove item from cart.
  • Update item quantity in cart.
  • Update selected options for an item (e.g., size, toppings).
• Reads:
  • Fetch a user's active cart quickly (commonly by (user_id, merchant_id) or (user_id, status)).
  • Fetch full cart details, including header information and the complete list of items, by cart_id.
• Checkout:
  • Convert an active cart into an order exactly once.
  • Validate correctness during checkout (e.g., prices/options are current, cart is not stale, cart has not already been checked out).

Non-Functional Requirements

• Correctness/Consistency: This is the top priority, especially during the checkout process.
• Latency & Availability: Low latency and high availability are important for all operations but must not compromise correctness at checkout.
• Concurrency: The system must handle multiple devices updating the same cart concurrently.

Scale Assumptions

• The system should be designed to support up to 10 million concurrent orders. Use this metric to derive rough QPS (Queries Per Second) and storage assumptions.

Data Modeling Expectations

• Propose a data model and indexing strategy that efficiently supports typical queries and ensures correctness.
  • Examples of typical queries to support:
    • Get a user’s active cart quickly (often by (user_id, merchant_id) or (user_id, status)).
    • Get all items by cart_id.
    • At checkout, read cart and its items efficiently and validate consistency.
• Discuss how to handle optimistic concurrency control (e.g., using a version field on the cart header and conditional writes).
• Be prepared to discuss finer-grained conflict resolution (e.g., allowing two devices to modify different items within the same cart without conflict) if prompted.