Designing Amazon: E-Commerce at Massive Scale

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

=== TRAFFIC ESTIMATION ===
 
Daily Active Users (DAU): 500 million
Average Sessions per User per Day: 1.5
Page Views per Session: 8
 
Total Daily Page Views: 500M × 1.5 × 8 = 6 billion page views/day
Queries Per Second (QPS): 6B / 86,400 = ~70,000 QPS (average)
Peak QPS: 5× average = ~350,000 QPS
 
=== CART OPERATIONS ===
 
Users who add to cart: 30% of sessions
Items added per cart session: 3.5 (average)
Cart add operations per day: 500M × 1.5 × 0.30 × 3.5 = ~790 million
 
Cart QPS: 790M / 86,400 = ~9,100 QPS (average)
Peak Cart QPS: 5× average = ~45,000 QPS
 
=== ORDER VOLUME ===
 
Conversion Rate: 2.5% of sessions result in order
Orders per Day: 500M × 1.5 × 0.025 = ~18.75 million orders/day
Orders Per Second: 18.75M / 86,400 = ~217 orders/second (average)
Peak Orders Per Second: 10× average during events = ~2,200 OPS

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

=== CATALOG STORAGE ===
 
Total Products: 350 million
Average Product Data Size: 50 KB (text, attributes, metadata)
Total Catalog Storage: 350M × 50 KB = 17.5 TB
 
Product Images per Product: 8 (average)
Average Image Size: 500 KB (optimized)
Total Image Storage: 350M × 8 × 500 KB = 1.4 PB
 
=== CART STORAGE ===
 
Active Carts (30-day active): 200 million
Average Cart Size: 2 KB (item references, quantities)
Active Cart Storage: 200M × 2 KB = 400 GB
 
Cart History (1 year): 2 billion carts
Total Cart Storage: 2B × 2 KB = 4 TB
 
=== ORDER STORAGE ===
 
Orders per Year: 18.75M × 365 = 6.84 billion
Average Order Record Size: 10 KB (items, addresses, payment refs)
Annual Order Storage: 6.84B × 10 KB = 68.4 TB
Order History (5 years): 342 TB
 
=== INVENTORY DATA ===
 
Inventory Records: 350M products × 10 regional warehouses = 3.5B
Record Size: 100 bytes (product ID, warehouse, quantity, reserved)
Total Inventory Data: 3.5B × 100 bytes = 350 GB (small but HOT)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// Product Catalog Service API
 
interface ProductCatalogAPI {
  // Product retrieval
  getProduct(productId: string): Promise<Product>;
  getProductVariants(productId: string): Promise<ProductVariant[]>;
  
  // Search and discovery
  searchProducts(query: SearchQuery): Promise<SearchResults>;
  getCategory(categoryId: string): Promise<Category>;
  getCategoryProducts(categoryId: string, pagination: Pagination): Promise<ProductList>;
  
  // Pricing (real-time, may include dynamic pricing)
  getPrice(productId: string, variantId?: string, userId?: string): Promise<Price>;
  
  // Availability (delegates to inventory service internally)
  getAvailability(productId: string, variantId: string, location: Location): Promise<Availability>;
}
 
interface SearchQuery {
  query: string;
  filters: Filter[];       // Brand, price range, ratings, etc.
  sortBy: SortOption;      // Relevance, price, rating, newest
  pagination: Pagination;
  userId?: string;         // For personalized ranking
}
 
interface SearchResults {
  products: ProductSummary[];
  facets: Facet[];         // Available filter options with counts
  totalCount: number;
  pagination: PaginationResult;
  searchMetadata: {
    queryInterpretation: string;
    spellCorrection?: string;
    suggestedQueries: string[];
  };
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// Shopping Cart Service API
 
interface CartAPI {
  // Cart operations
  getCart(sessionId: string, userId?: string): Promise<Cart>;
  addToCart(request: AddToCartRequest): Promise<CartUpdateResult>;
  updateQuantity(request: UpdateQuantityRequest): Promise<CartUpdateResult>;
  removeFromCart(request: RemoveFromCartRequest): Promise<CartUpdateResult>;
  
  // Session management
  mergeGuestCart(guestSessionId: string, userId: string): Promise<Cart>;
  
  // Saved items
  saveForLater(cartItemId: string): Promise<void>;
  moveToCart(savedItemId: string): Promise<CartUpdateResult>;
  
  // Validation
  validateCart(sessionId: string): Promise<CartValidationResult>;
}
 
interface AddToCartRequest {
  sessionId: string;
  userId?: string;
  productId: string;
  variantId: string;
  quantity: number;
  metadata?: Record<string, string>;  // Gift wrapping, customization
}
 
interface CartUpdateResult {
  cart: Cart;
  success: boolean;
  warnings: CartWarning[];   // Low stock, price changed, etc.
  errors: CartError[];       // Out of stock, invalid variant, etc.
}
 
interface Cart {
  id: string;
  items: CartItem[];
  subtotal: Money;
  estimatedShipping: Money;
  estimatedTax: Money;
  total: Money;
  appliedPromotions: Promotion[];
  lastUpdated: Timestamp;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

// Checkout Service API
 
interface CheckoutAPI {
  // Checkout flow
  initiateCheckout(cartId: string): Promise<CheckoutSession>;
  setShippingAddress(sessionId: string, address: Address): Promise<CheckoutSession>;
  setShippingOption(sessionId: string, optionId: string): Promise<CheckoutSession>;
  applyPromoCode(sessionId: string, code: string): Promise<PromoCodeResult>;
  
  // Payment
  setPaymentMethod(sessionId: string, paymentMethod: PaymentMethod): Promise<CheckoutSession>;
  submitOrder(sessionId: string): Promise<OrderResult>;
  
  // Order retrieval
  getOrder(orderId: string, userId: string): Promise<Order>;
  getOrderHistory(userId: string, pagination: Pagination): Promise<OrderList>;
}
 
interface CheckoutSession {
  id: string;
  cart: Cart;
  shippingAddress?: Address;
  billingAddress?: Address;
  shippingOptions: ShippingOption[];
  selectedShipping?: ShippingOption;
  paymentMethod?: PaymentMethodSummary;
  
  // Calculated totals
  subtotal: Money;
  shippingCost: Money;
  tax: Money;
  discount: Money;
  total: Money;
  
  // Validation state
  readyForPayment: boolean;
  validationErrors: ValidationError[];
  expiresAt: Timestamp;
}
 
interface OrderResult {
  success: boolean;
  orderId?: string;
  confirmationNumber?: string;
  estimatedDelivery?: DateRange;
  error?: PaymentError | InventoryError;
}