E-Commerce Platform (Amazon Scale)

/* ━━━ NAPKIN MATH: Start From Users ━━━ */
Registered users: 300M
DAU: 50M (17% of registered)
DAU on Prime Day: 150M (3x normal)

/* ━━━ SEARCH ━━━ */
Searches/day (normal): 50M users × 5 searches = 250M/day
Search QPS (avg): 250M / 86,400 ≈ 2,900/sec
Search QPS (Prime Day peak): 2,900 × 10 = 29,000/sec

/* ━━━ PRODUCT PAGE VIEWS ━━━ */
Views/day: 50M × 20 pages = 1B/day
Page view QPS (avg): 1B / 86,400 ≈ 11,500/sec
Page view QPS (peak): ~115,000/sec → CDN must absorb 80%+

/* ━━━ ORDERS ━━━ */
Orders/day (normal): 5M
Order QPS (avg): 5M / 86,400 ≈ 58/sec
Order QPS (Prime Day peak): 50,000/sec (burst in first hour)
Orders in first hour of Prime Day: ~50M

/* ━━━ CART ━━━ */
Cart operations/sec (peak): 200K (add/update/remove)
Active carts at any time: ~10M
Cart data per user: ~2 KB (10 items × 200 bytes)
Total hot cart data: 10M × 2 KB = 20 GB → fits in Redis cluster

/* ━━━ INVENTORY ━━━ */
Products in catalog: 500M SKUs
Products with active inventory: ~100M
Inventory updates/sec (peak): 500K (order reservations + restocks)

/* ━━━ STORAGE ━━━ */
Product data: 500M × 5 KB (text) = 2.5 TB
Product images: 500M × 10 images × 500 KB = 2.5 PB (S3 + CDN)
Order history (5yr): 5M/day × 365 × 5 × 2 KB = 18 TB
Search index: ~500 GB (Elasticsearch)

/* ━━━ BANDWIDTH ━━━ */
Peak inbound (API): ~2 GB/sec
Peak outbound (pages + images): ~50 GB/sec → 90% from CDN

┌─────────────────────────────────────────────────────────────────────────────────────┐
│                              CLIENTS (Web / Mobile / API)                            │
└─────────────────────┬───────────────────────────────────────────────────────────────┘
                      │
                      ▼
┌─────────────────────────────────────────────────────────────────────────────────────┐
│                         CDN (CloudFront) + WAF + Rate Limiter                        │
│          Static assets, product images, cached catalog pages (80% hit rate)          │
└─────────────────────┬───────────────────────────────────────────────────────────────┘
                      │ cache miss / API calls
                      ▼
┌─────────────────────────────────────────────────────────────────────────────────────┐
│                            API Gateway / Load Balancer                                │
│         Route: /search → Search, /cart → Cart, /orders → Order, etc.                 │
│         Auth, rate limiting, request logging, circuit breaker                         │
└──┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬────────────────┘
   │          │          │          │          │          │          │
   ▼          ▼          ▼          ▼          ▼          ▼          ▼
┌──────┐ ┌──────┐ ┌──────┐ ┌──────────┐ ┌──────┐ ┌──────────┐ ┌────────────────┐
│Search│ │Catalog│ │ Cart │ │  Order   │ │Inven-│ │ Payment  │ │ Recommendation │
│ Svc  │ │ Svc  │ │ Svc  │ │  Svc     │ │tory  │ │   Svc    │ │     Svc        │
└──┬───┘ └──┬───┘ └──┬───┘ └────┬─────┘ └──┬───┘ └────┬─────┘ └───────┬────────┘
   │         │        │          │           │          │                │
   ▼         ▼        ▼          ▼           ▼          ▼                ▼
┌──────┐ ┌───────┐ ┌─────┐ ┌─────────┐ ┌─────────┐ ┌──────────┐ ┌──────────────┐
│Elast-│ │Product│ │Redis│ │Order DB │ │Inventory│ │ Payment  │ │   ML Model   │
│search│ │  DB   │ │Clust│ │(sharded)│ │   DB    │ │ Gateway  │ │   Store      │
│Clust.│ │(Dynamo│ │er   │ │PostgreSQL│ │PostgreSQL│ │(Stripe/  │ │(Feature DB)  │
└──────┘ │  DB)  │ └─────┘ └─────────┘ └─────────┘ │ internal)│ └──────────────┘
         └───────┘                                   └──────────┘

                    ┌─────────────────────────────────┐
                    │        Kafka Event Bus           │
                    │  Topics: orders, inventory,      │
                    │  payments, notifications         │
                    └──────────┬──────────────────────┘
                               │
               ┌───────────────┼───────────────┐
               ▼               ▼               ▼
        ┌────────────┐  ┌────────────┐  ┌────────────┐
        │Fulfillment │  │Notification│  │ Analytics  │
        │  Service   │  │  Service   │  │  Pipeline  │
        └────────────┘  └────────────┘  └────────────┘

1. Token analysis: "wireless headphones" → ["wireless", "headphones"]
2. Inverted index lookup → 15,000 matching products
3. Filtering: in_stock=true, ships_to=IN, Prime_eligible=true → 8,200 products
4. BM25 text relevance score
5. ML re-ranking: personalization (Priya's history), conversion rate, seller rating
6. Return top 48 results (page 1) with facets (brand, price range, rating)

Priya → CDN (miss) → API GW → Search Svc → ES Cluster + Redis enrichment → results (280ms)

1. Redis HSET cart:{user_id} SONY-WH1000XM5-BLK '{"qty":1,"price":29999,"added_at":"..."}'
2. Redis EXPIRE cart:{user_id} 2592000  (30-day TTL)
3. Async: write-behind to Cart DB (PostgreSQL) for durability
4. Async: publish CartUpdated event to Kafka (for recommendation engine)

Priya → API GW → Cart Svc → Redis (write) → success (3ms)
                          → async: DB persist + Kafka event

For each item in cart:
  GET /inventory/{sku}/available → returns {available: 847, reserved: 153}
  If available < requested_qty → mark item as "out of stock" in response

INSERT INTO orders (order_id, user_id, status, items, total, created_at)
VALUES ('ORD-7829341', 'USR-PRIYA', 'CREATED', [...], 29999, NOW())

BEGIN TRANSACTION
  SELECT quantity, version FROM inventory WHERE sku = 'SONY-WH1000XM5-BLK' FOR UPDATE
  -- quantity = 847, version = 4291
  IF quantity >= 1:
    UPDATE inventory SET quantity = quantity - 1, version = version + 1
      WHERE sku = 'SONY-WH1000XM5-BLK' AND version = 4291
    -- Optimistic lock: if version changed (concurrent update), RETRY
    INSERT INTO reservations (order_id, sku, qty, expires_at)
      VALUES ('ORD-7829341', 'SONY-WH1000XM5-BLK', 1, NOW() + INTERVAL '10 min')
  ELSE:
    ROLLBACK → return "OUT_OF_STOCK"
COMMIT

Order Svc → Payment Svc → Stripe API
  charge_id = stripe.charges.create(amount=29999, currency='INR', idempotency_key='ORD-7829341')
  // Idempotency key prevents double-charging on retry

Order Svc publishes to Kafka: "OrderConfirmed" {order_id, items, address, ...}
  → Fulfillment Svc: assigns warehouse, generates shipping label
  → Notification Svc: sends email + push notification to Priya
  → Inventory Svc: converts reservation to permanent decrement
  → Analytics: records conversion event

Full checkout trace:
Priya → API GW → Cart Svc (validate) → Order Svc (create)
  → Inventory Svc (reserve, optimistic lock)
  → Payment Svc (charge via Stripe, idempotent)
  → Order Svc (confirm) → Kafka → [Fulfillment, Notification, Analytics]
Total: ~600ms

1. Payment Service publishes "PaymentCaptured" event to Kafka (durable, replicated)
2. Order Service restarts. On boot, it replays unprocessed Kafka events.
3. Finds "PaymentCaptured" for ORD-7829341 with no matching "OrderConfirmed"
4. Reconstructs order state from Kafka event log → marks as CONFIRMED
5. If reconstruction fails after 3 retries:
   → Saga compensation: Payment Service issues automatic refund
   → Notification Service alerts Priya: "Order failed, refund issued"
   → Inventory Service releases the reservation

1. Circuit breaker opens after 5 consecutive Inventory Service timeouts
2. Order Service switches to "optimistic mode":
   - Creates order with status PENDING_INVENTORY_CHECK
   - Responds to user: "Order received! Confirming availability..."
   - Queues reservation request in Kafka
3. When Inventory Service recovers:
   - Processes queued reservations in order
   - If stock available: confirms order normally
   - If out of stock: cancels order, notifies user, triggers refund

1. Cart Service falls back to PostgreSQL (cart_backup table)
   - Write-behind ensures carts are persisted with < 5s staleness
   - Latency increases from 3ms to 15ms (acceptable for cart operations)
2. Redis Cluster uses 3 replicas per shard — single node failure is transparent
3. Full cluster failure: serve from DB, queue cart writes in memory + Kafka
4. Recovery: warm Redis from DB using background scan (10M carts × 2KB = 20GB, ~5 min)

1. Circuit breaker reduces ES queries to "simple mode" (fewer filters, no ML re-ranking)
2. Serve cached "top results" per category from Redis (pre-computed hourly)
3. Autocomplete continues from Redis prefix cache (independent of ES)
4. Product pages still accessible via direct URL (Catalog Service is unaffected)
5. "Browse by category" fallback shows pre-computed product lists

1. Pre-warm: 30 min before launch, scale all services to Prime Day capacity
2. CDN pre-cache: push deal pages to all CDN PoPs before launch
3. Queue-based admission: checkout requests enter a virtual queue (like ticket systems)
   - User sees: "You're in line! Estimated wait: 2 minutes"
   - Prevents inventory service from being overwhelmed with 50K concurrent reservations
4. Rate limiting per user: max 5 orders/minute prevents bot abuse
5. Deal inventory: pre-partitioned across inventory shards to avoid hot-key contention

/* ━━━ PRODUCT CATALOG (DynamoDB) ━━━ */

Table: products
  PK: sku (String)          -- "SONY-WH1000XM5-BLK"
  Attributes:
    title        String     -- "Sony WH-1000XM5 Wireless Headphones"
    description  String     -- Rich text, 2-5 KB
    brand        String     -- "Sony"
    category     List       -- ["Electronics", "Headphones", "Over-Ear"]
    price        Number     -- 29999 (cents, avoids floating point)
    images       List       -- [S3 URLs]
    attributes   Map        -- {"color": "Black", "connectivity": "Bluetooth 5.2", ...}
    rating       Number     -- 4.7
    review_count Number     -- 12847
    seller_id    String     -- "SELLER-SONY-OFFICIAL"
    created_at   String     -- ISO 8601

  GSI: category-price-index (category, price) -- for filtered browsing
  GSI: brand-index (brand, rating)            -- for brand pages

/* ━━━ INVENTORY (PostgreSQL — sharded by sku hash) ━━━ */

CREATE TABLE inventory (
    sku           VARCHAR(64)  PRIMARY KEY,
    quantity      INT          NOT NULL CHECK (quantity >= 0),
    reserved      INT          NOT NULL DEFAULT 0,
    warehouse_id  VARCHAR(32)  NOT NULL,
    version       BIGINT       NOT NULL DEFAULT 0,  -- optimistic lock
    updated_at    TIMESTAMPTZ  DEFAULT NOW()
);

CREATE TABLE reservations (
    reservation_id  UUID         PRIMARY KEY DEFAULT gen_random_uuid(),
    order_id        VARCHAR(32)  NOT NULL,
    sku             VARCHAR(64)  NOT NULL,
    quantity        INT          NOT NULL,
    status          VARCHAR(16)  DEFAULT 'HELD',  -- HELD | CONFIRMED | RELEASED
    expires_at      TIMESTAMPTZ  NOT NULL,
    created_at      TIMESTAMPTZ  DEFAULT NOW()
);

CREATE INDEX idx_reservation_expiry ON reservations (expires_at) WHERE status = 'HELD';
CREATE INDEX idx_reservation_order  ON reservations (order_id);

/* ━━━ ORDERS (PostgreSQL — sharded by user_id hash) ━━━ */

CREATE TABLE orders (
    order_id     VARCHAR(32)  PRIMARY KEY,
    user_id      VARCHAR(32)  NOT NULL,
    status       VARCHAR(20)  NOT NULL,  -- CREATED|PAYMENT_PENDING|CONFIRMED|SHIPPED|DELIVERED|CANCELLED|RETURNED
    items        JSONB        NOT NULL,  -- [{sku, qty, price, title}]
    subtotal     BIGINT       NOT NULL,  -- cents
    tax          BIGINT       NOT NULL,
    shipping_fee BIGINT       NOT NULL,
    total        BIGINT       NOT NULL,
    address      JSONB        NOT NULL,
    payment_id   VARCHAR(64),
    created_at   TIMESTAMPTZ  DEFAULT NOW(),
    updated_at   TIMESTAMPTZ  DEFAULT NOW()
);

CREATE TABLE order_events (
    event_id    UUID          PRIMARY KEY DEFAULT gen_random_uuid(),
    order_id    VARCHAR(32)   NOT NULL,
    event_type  VARCHAR(32)   NOT NULL,  -- CREATED, PAYMENT_CAPTURED, CONFIRMED, SHIPPED, ...
    payload     JSONB,
    created_at  TIMESTAMPTZ   DEFAULT NOW()
);

CREATE INDEX idx_orders_user   ON orders (user_id, created_at DESC);
CREATE INDEX idx_orders_status ON orders (status) WHERE status IN ('CREATED', 'PAYMENT_PENDING');

/* ━━━ CART (Redis) ━━━ */

-- Hash per user
HSET cart:USR-PRIYA SONY-WH1000XM5-BLK '{"qty":1,"price":29999,"added_at":"2026-06-07T10:00:00Z"}'
HSET cart:USR-PRIYA KINDLE-PW-2026      '{"qty":1,"price":14999,"added_at":"2026-06-07T10:01:00Z"}'
EXPIRE cart:USR-PRIYA 2592000  -- 30-day TTL

-- Guest cart (session-based)
HSET cart:SESSION-abc123 SONY-WH1000XM5-BLK '{"qty":1,"price":29999,"added_at":"..."}'
EXPIRE cart:SESSION-abc123 86400  -- 24-hour TTL for guests

-- On login: merge guest cart into user cart
-- Conflict resolution: user cart item wins on quantity, guest cart adds new items

/* ━━━ SEARCH INDEX (Elasticsearch) ━━━ */

PUT /products
{
  "mappings": {
    "properties": {
      "sku":          {"type": "keyword"},
      "title":        {"type": "text", "analyzer": "standard", "fields": {"keyword": {"type": "keyword"}}},
      "description":  {"type": "text", "analyzer": "standard"},
      "brand":        {"type": "keyword"},
      "category":     {"type": "keyword"},
      "price":        {"type": "integer"},
      "rating":       {"type": "float"},
      "review_count": {"type": "integer"},
      "in_stock":     {"type": "boolean"},
      "prime":        {"type": "boolean"},
      "sales_rank":   {"type": "integer"},
      "embedding":    {"type": "dense_vector", "dims": 768}  -- for semantic search
    }
  }
}

function reserve_inventory(order_id, sku, requested_qty):
    MAX_RETRIES = 3
    for attempt in range(MAX_RETRIES):
        // Read current state
        row = db.query("SELECT quantity, version FROM inventory WHERE sku = $1", sku)

        if row.quantity < requested_qty:
            return ERROR("OUT_OF_STOCK")

        // Attempt atomic update with version check (optimistic lock)
        affected = db.execute("""
            UPDATE inventory
            SET quantity = quantity - $1, version = version + 1
            WHERE sku = $2 AND version = $3 AND quantity >= $1
        """, requested_qty, sku, row.version)

        if affected == 1:
            // Success — record the reservation
            db.execute("""
                INSERT INTO reservations (order_id, sku, quantity, status, expires_at)
                VALUES ($1, $2, $3, 'HELD', NOW() + INTERVAL '10 minutes')
            """, order_id, sku, requested_qty)
            return SUCCESS(reservation_id)

        // Version conflict — another transaction updated first. Retry.
        sleep(random(5, 50) ms)  // jittered backoff

    return ERROR("CONTENTION_TOO_HIGH")  // after 3 retries, fail gracefully

// Runs every 30 seconds — releases reservations for abandoned checkouts
function release_expired_reservations():
    expired = db.query("""
        SELECT reservation_id, sku, quantity FROM reservations
        WHERE status = 'HELD' AND expires_at < NOW()
        LIMIT 1000
    """)
    for r in expired:
        db.execute("UPDATE inventory SET quantity = quantity + $1 WHERE sku = $2", r.quantity, r.sku)
        db.execute("UPDATE reservations SET status = 'RELEASED' WHERE reservation_id = $1", r.reservation_id)

                    ┌──────────────────────────────────────────────┐
                    │                                              │
                    ▼                                              │
┌─────────┐    ┌───────────────┐    ┌───────────┐    ┌─────────┐ │
│ CREATED │───▶│PAYMENT_PENDING│───▶│ CONFIRMED │───▶│ SHIPPED │ │
└─────────┘    └───────────────┘    └───────────┘    └─────────┘ │
     │                │                    │               │       │
     │                │                    │               ▼       │
     │                │                    │          ┌──────────┐ │
     │                │                    │          │DELIVERED │ │
     │                │                    │          └──────────┘ │
     │                │                    │               │       │
     │                ▼                    ▼               ▼       │
     │          ┌──────────┐         ┌──────────┐   ┌──────────┐  │
     └─────────▶│CANCELLED │         │CANCELLED │   │ RETURNED │──┘
                └──────────┘         └──────────┘   └──────────┘

VALID_TRANSITIONS = {
    CREATED:         [PAYMENT_PENDING, CANCELLED],
    PAYMENT_PENDING: [CONFIRMED, CANCELLED],      // cancelled if payment fails
    CONFIRMED:       [SHIPPED, CANCELLED],         // cancelled before ship
    SHIPPED:         [DELIVERED],
    DELIVERED:       [RETURNED],                   // return window (30 days)
    CANCELLED:       [],                           // terminal state
    RETURNED:        [CONFIRMED],                  // re-ship if return rejected
}

function transition_order(order_id, new_status, metadata):
    order = db.query("SELECT * FROM orders WHERE order_id = $1 FOR UPDATE", order_id)

    if new_status not in VALID_TRANSITIONS[order.status]:
        return ERROR("Invalid transition: {order.status} → {new_status}")

    db.execute("UPDATE orders SET status = $1, updated_at = NOW() WHERE order_id = $2",
               new_status, order_id)

    // Record event for audit trail and event sourcing
    db.execute("""INSERT INTO order_events (order_id, event_type, payload)
                  VALUES ($1, $2, $3)""", order_id, new_status, metadata)

    // Publish state change to Kafka for downstream services
    kafka.produce("order-events", {
        order_id: order_id,
        previous_status: order.status,
        new_status: new_status,
        timestamp: now(),
        metadata: metadata
    })

    // Trigger side effects based on transition
    match new_status:
        CANCELLED:
            inventory_service.release_reservation(order_id)
            if order.payment_id:
                payment_service.refund(order.payment_id)
            notification_service.send(order.user_id, "Order cancelled")
        SHIPPED:
            notification_service.send(order.user_id, "Order shipped! Track: {metadata.tracking}")
        DELIVERED:
            notification_service.send(order.user_id, "Order delivered!")
        RETURNED:
            inventory_service.restock(order.items)
            payment_service.refund(order.payment_id)

function merge_carts(user_id, session_id):
    guest_cart = redis.HGETALL("cart:SESSION-{session_id}")
    user_cart  = redis.HGETALL("cart:{user_id}")

    if not guest_cart:
        return  // nothing to merge

    for sku, guest_item in guest_cart:
        if sku in user_cart:
            // Conflict: item exists in both carts
            // Strategy: keep higher quantity (user was likely price-watching)
            user_item = parse(user_cart[sku])
            guest_data = parse(guest_item)
            merged_qty = max(user_item.qty, guest_data.qty)
            redis.HSET("cart:{user_id}", sku,
                       json({qty: merged_qty, price: guest_data.price, added_at: now()}))
        else:
            // New item from guest session — add to user cart
            redis.HSET("cart:{user_id}", sku, guest_item)

    // Clean up guest cart
    redis.DEL("cart:SESSION-{session_id}")

    // Refresh TTL on merged cart
    redis.EXPIRE("cart:{user_id}", 2592000)  // 30 days

function rank_results(query, raw_results, user_context):
    scored_results = []
    for product in raw_results:
        score = 0.0

        // Factor 1: Text relevance (from Elasticsearch BM25)
        score += product.es_score * 0.3

        // Factor 2: Popularity (conversion rate × recency)
        score += product.conversion_rate * 0.2
        score += log(product.order_count_30d + 1) * 0.1

        // Factor 3: User personalization
        if product.category in user_context.purchase_history:
            score += 0.15  // bought from this category before
        if product.brand in user_context.brand_affinity:
            score += 0.10  // frequently buys this brand

        // Factor 4: Product quality signals
        score += (product.rating / 5.0) * 0.1
        score += min(log(product.review_count) / 5, 1.0) * 0.05

        // Factor 5: Business rules
        if product.is_prime:
            score += 0.05  // slight Prime boost for Prime members
        if product.is_sponsored:
            score += product.bid_amount * 0.001  // paid placement

        // Penalty: out of stock items ranked lower
        if not product.in_stock:
            score *= 0.1

        scored_results.append((product, score))

    return sorted(scored_results, key=lambda x: x[1], reverse=True)