Design a Ticketing System (BookMyShow / Ticketmaster)

-- Redis Lua script: atomic multi-seat hold
-- KEYS = list of seat lock keys for the same show
-- ARGV[1] = hold_id, ARGV[2] = TTL in seconds

-- Phase 1: Check all seats are available
for i, key in ipairs(KEYS) do
    if redis.call('EXISTS', key) == 1 then
        return {0, key}  -- FAIL: seat already held
    end
end

-- Phase 2: Lock all seats atomically
for i, key in ipairs(KEYS) do
    redis.call('SET', key, ARGV[1], 'EX', ARGV[2])
end

return {1, 'OK'}  -- SUCCESS: all seats held

BEGIN;

-- 1. Lock the requested seats in deterministic order
SELECT seat_id, status, held_until
FROM seats
WHERE show_id = $1
  AND seat_id = ANY($2)
ORDER BY seat_id
FOR UPDATE;

-- 2. Verify every requested seat is available or has an expired hold
--    Count seats that were already available before this transition.

-- 3. Transition the requested seats to HELD
UPDATE seats
SET status = 'held',
    held_by = $3,
    hold_id = $4,
    held_until = NOW() + INTERVAL '10 minutes',
    version = version + 1
WHERE show_id = $1
  AND seat_id = ANY($2)
  AND (status = 'available' OR held_until < NOW());

-- 4. Verify row count = requested seat count

-- 5. Decrement only seats that were actually available before the transition
UPDATE shows
SET available_seats = available_seats - $5
WHERE show_id = $1
  AND available_seats >= $5;

-- 6. Insert the hold and its transactional outbox event
-- 7. Commit
COMMIT;

BEGIN;

-- 1. Verify the hold and lock its row
SELECT hold_id, user_id, show_id, seat_ids, quoted_total_amount, hold_expires_at
FROM seat_holds
WHERE hold_id = $1
  AND user_id = $2
  AND status = 'active'
  AND hold_expires_at > NOW()
FOR UPDATE;

-- 2. Authorization was already persisted by the Payment Service before this transaction.
--    Do not make a network call to the Payment Service or external PSP while this transaction is open.

-- 3. Promote every held seat owned by this hold to BOOKED
UPDATE seats
SET status = 'booked',
    booked_by = $2,
    booking_id = $3,
    version = version + 1
WHERE show_id = $4
  AND seat_id = ANY($5)
  AND status = 'held'
  AND hold_id = $1
  AND held_by = $2;

-- 4. Verify row count = expected seat count

-- 5. Persist the booking as pending_capture
INSERT INTO bookings (
    booking_id, user_id, show_id, hold_id, seat_ids,
    total_amount, payment_id, status, idempotency_key, booked_at
)
VALUES (
    $3, $2, $4, $1, $5,
    $6, $7, 'pending_capture', $8, NOW()
);

-- 6. Record the booking event in the outbox
INSERT INTO booking_outbox (event_id, booking_id, event_type, payload, created_at)
VALUES ($10, $3, 'pending_capture', $11, NOW());

-- 7. Insert the audit record
INSERT INTO booking_audit_log (booking_id, action, actor, details, created_at)
VALUES ($3, 'BOOKING_COMMITTED_PENDING_CAPTURE', $2, '{"seats": ...}', NOW());

-- 8. Record the seat status outbox event in the same transaction
INSERT INTO seat_status_outbox (event_id, show_id, seat_ids, status, created_at)
VALUES ($9, $4, $5, 'booked', NOW());

COMMIT;

-- Outside the transaction:
-- 9. Capture payment using an idempotency key.
-- 10. On capture success, mark booking confirmed and write the confirmed booking event outbox record.
-- 11. On capture failure, release the booking or start the compensation workflow.

# Queue drainer worker loop
while True:
    # Pop the next batch of users whose turn has arrived
    users = redis.zpopmin(f"queue:{event_id}", count=BATCH_SIZE)

    for user_id, score in users:
        token = jwt.encode({
            "user_id": user_id,
            "event_id": event_id,
            "issued_at": now(),
            "expires_at": now() + timedelta(minutes=10),
            "max_tickets": 4
        }, SECRET_KEY)

        # Notify the user. The client can also poll queue status.
        push_notification(user_id, {"status": "your_turn", "booking_token": token})

    sleep(BATCH_SIZE / DRAIN_RATE)

{
  "type": "seat_update",
  "show_id": "show-uuid",
  "updates": [
    {"seat_id": "P-A1", "status": "held"},
    {"seat_id": "P-A2", "status": "held"}
  ]
}

# Runs every 30 seconds
def cleanup_expired_holds():
    db.begin_transaction()

    expired = db.query("""
        SELECT hold_id, show_id, seat_ids
        FROM seat_holds
        WHERE status = 'active' AND hold_expires_at < NOW()
        FOR UPDATE SKIP LOCKED
        LIMIT 500
    """)

    redis_releases = []

    for hold in expired:
        changed = db.execute("""
            UPDATE seat_holds
            SET status = 'expired'
            WHERE hold_id = %s
              AND status = 'active'
              AND hold_expires_at < NOW()
        """, hold.hold_id)

        if changed.rowcount != 1:
            continue

        released_ids = db.query("""
            UPDATE seats
            SET status = 'available',
                held_by = NULL,
                hold_id = NULL,
                held_until = NULL,
                version = version + 1
            WHERE show_id = %s
              AND hold_id = %s
              AND status = 'held'
            RETURNING seat_id
        """, hold.show_id, hold.hold_id)

        db.execute("""
            UPDATE shows
            SET available_seats = available_seats + %s
            WHERE show_id = %s
        """, len(released_ids), hold.show_id)

        if released_ids:
            db.execute("""
                INSERT INTO seat_status_outbox (event_id, show_id, seat_ids, status, created_at)
                VALUES (%s, %s, %s, 'available', NOW())
            """, uuid4(), hold.show_id, released_ids)
            redis_releases.append((hold.show_id, hold.hold_id, released_ids))

    db.commit()

    for show_id, hold_id, released_ids in redis_releases:
        # Redis locks are removed only when the stored value still matches hold_id.
        redis.release_matching_locks(show_id, released_ids, hold_id)

Topic: seat-status-changes
  Partitions: 64 (partition by show_id so all seat deltas for one show remain ordered)
  Retention: 24h (supports real-time seat maps while analytics sinks to data warehouse)
  Producers: Seat Status Outbox Publisher after Booking Service or Hold Expiry Worker commits state
  Consumers: Seat Map Service (WebSocket fan-out), availability cache updater, analytics

Topic: booking-events
  Partitions: 32 (partition by booking_id)
  Retention: 30 days
  Producers: Booking Service outbox publisher (pending_capture, confirmed, cancelled)
  Consumers: Notification Service, waitlist consumer, analytics (ClickHouse)

Topic: payment-events
  Partitions: 16 (partition by payment_id)
  Producers: Payment Service outbox publisher after local payment state commits (authorized, captured, voided, refunded)
  Consumers: Booking Service, reconciliation workers

Topic: notification-events
  Partitions: 16 (partition by user_id)
  Producers: Notification Service
  Consumers: email/SMS/push workers

Replication factor: 3, min.insync.replicas: 2, producer acks: all
Reliability pattern: PostgreSQL transaction writes authoritative seat state and an outbox record atomically. The outbox publisher delivers Kafka events at least once, and downstream consumers deduplicate by event_id.
Sync path: Redis atomic pre-gate → PostgreSQL authoritative hold transaction → return hold_id
Async path: seat map push, analytics, notifications, search updates