Design Ticketmaster: The System Design That Handles 10M Concurrent Requests Without Crashing

// io.thecodeforge — System Design tutorial

// Shard routing logic for event inventory
// Uses consistent hashing to map event to shard

class ShardRouter {
    private static final int NUM_SHARDS = 64;
    private final Map<Integer, DatabasePool> shardPools;

    public ShardRouter(List<DatabasePool> pools) {
        // Initialize 64 shard pools from config
        shardPools = new HashMap<>();
        for (int i = 0; i < NUM_SHARDS; i++) {
            shardPools.put(i, pools.get(i % pools.size()));
        }
    }

    public DatabasePool getShardForEvent(String eventId) {
        // Use consistent hash to avoid rehashing on pool changes
        int shardId = Math.abs(eventId.hashCode()) % NUM_SHARDS;
        return shardPools.get(shardId);
    }

    public void reserveSeat(String eventId, String seatId, String userId) {
        DatabasePool pool = getShardForEvent(eventId);
        try (Connection conn = pool.getConnection()) {
            // Use SELECT FOR UPDATE with NOWAIT to avoid blocking
            String sql = "SELECT status FROM seats WHERE event_id = ? AND seat_id = ? FOR UPDATE NOWAIT";
            PreparedStatement stmt = conn.prepareStatement(sql);
            stmt.setString(1, eventId);
            stmt.setString(2, seatId);
            ResultSet rs = stmt.executeQuery();
            if (rs.next() && "available".equals(rs.getString("status"))) {
                // Update status to reserved with TTL
                sql = "UPDATE seats SET status = 'reserved', reserved_by = ?, reserved_at = NOW() WHERE event_id = ? AND seat_id = ?";
                stmt = conn.prepareStatement(sql);
                stmt.setString(1, userId);
                stmt.setString(2, eventId);
                stmt.setString(3, seatId);
                stmt.executeUpdate();
            } else {
                throw new SeatUnavailableException("Seat " + seatId + " is not available");
            }
        } catch (SQLException e) {
            if (e.getSQLState().equals("55P03")) { // NOWAIT lock not available
                throw new SeatUnavailableException("Seat is locked by another transaction");
            }
            throw new RuntimeException(e);
        }
    }
}

// io.thecodeforge — System Design tutorial

// Lua script for atomic seat reservation in Redis
// Called via EVALSHA for performance

-- KEYS[1] = event:{eventId}:seats (hash)
-- ARGV[1] = seatId
-- ARGV[2] = userId
-- ARGV[3] = ttlSeconds

local seatStatus = redis.call('HGET', KEYS[1], ARGV[1])
if seatStatus == 'available' or seatStatus == false then
    redis.call('HSET', KEYS[1], ARGV[1], ARGV[2])
    redis.call('EXPIRE', KEYS[1], ARGV[3])
    return 1  -- success
else
    return 0  -- seat already reserved
end

// io.thecodeforge — System Design tutorial

// Order processing consumer that handles payment and seat confirmation

public class OrderProcessor implements Runnable {
    private final QueueClient queue;
    private final PaymentGateway paymentGateway;
    private final SeatInventoryClient inventoryClient;

    public OrderProcessor(QueueClient queue, PaymentGateway paymentGateway, SeatInventoryClient inventoryClient) {
        this.queue = queue;
        this.paymentGateway = paymentGateway;
        this.inventoryClient = inventoryClient;
    }

    @Override
    public void run() {
        while (true) {
            OrderMessage msg = queue.dequeue(30, TimeUnit.SECONDS); // long poll
            if (msg == null) continue;
            try {
                // Process payment
                PaymentResult result = paymentGateway.charge(msg.getUserId(), msg.getAmount());
                if (result.isSuccess()) {
                    // Confirm seat sale in database
                    inventoryClient.confirmSeats(msg.getEventId(), msg.getSeatIds(), msg.getUserId());
                    // Send confirmation email (async)
                    NotificationService.sendConfirmation(msg.getUserId(), msg.getEventId(), msg.getSeatIds());
                } else {
                    // Payment failed — release seats back to pool
                    inventoryClient.releaseSeats(msg.getEventId(), msg.getSeatIds());
                    // Notify user
                    NotificationService.sendPaymentFailed(msg.getUserId());
                }
            } catch (Exception e) {
                // Transient error — requeue with backoff
                if (msg.getRetryCount() < 3) {
                    msg.incrementRetry();
                    queue.enqueue(msg, 5 * msg.getRetryCount(), TimeUnit.SECONDS); // delayed retry
                } else {
                    // Dead letter — manual intervention
                    queue.sendToDeadLetter(msg);
                    logger.error("Order processing failed after 3 retries: {}", msg);
                }
            }
        }
    }
}

// io.thecodeforge — System Design tutorial

// Sliding window rate limiter using Redis sorted sets

public class SlidingWindowRateLimiter {
    private final Jedis jedis;
    private final int limit;
    private final long windowSizeMillis;

    public SlidingWindowRateLimiter(Jedis jedis, int limit, long windowSizeMillis) {
        this.jedis = jedis;
        this.limit = limit;
        this.windowSizeMillis = windowSizeMillis;
    }

    public boolean allowRequest(String userId) {
        String key = "ratelimit:" + userId;
        long now = System.currentTimeMillis();
        long windowStart = now - windowSizeMillis;

        // Use a transaction to ensure atomicity
        Transaction t = jedis.multi();
        // Remove entries outside the window
        t.zremrangeByScore(key, 0, windowStart);
        // Count remaining entries
        t.zcard(key);
        // Add current request
        t.zadd(key, now, String.valueOf(now));
        // Set TTL to avoid memory leaks
        t.expire(key, (int) (windowSizeMillis / 1000) + 1);
        List<Object> results = t.exec();

        long count = (Long) results.get(1); // zcard result
        return count <= limit;
    }
}

// io.thecodeforge — System Design tutorial

// Payment service with idempotency and circuit breaker

public class PaymentService {
    private final PaymentGateway gateway;
    private final CircuitBreaker circuitBreaker;
    private final IdempotencyStore idempotencyStore;

    public PaymentResult charge(String userId, String orderId, BigDecimal amount) {
        if (!circuitBreaker.isAllowed()) {
            throw new CircuitBreakerOpenException("Payment gateway is down, try again later");
        }
        String idempotencyKey = orderId + ":" + userId;
        // Check if we already processed this idempotency key
        PaymentResult cached = idempotencyStore.get(idempotencyKey);
        if (cached != null) {
            return cached;
        }
        try {
            PaymentResult result = gateway.charge(idempotencyKey, userId, amount);
            idempotencyStore.set(idempotencyKey, result, 24, TimeUnit.HOURS);
            circuitBreaker.recordSuccess();
            return result;
        } catch (GatewayTimeoutException e) {
            circuitBreaker.recordFailure();
            // Retry with same idempotency key
            throw e;
        } catch (GatewayDeclineException e) {
            // Payment declined — no retry
            idempotencyStore.set(idempotencyKey, PaymentResult.declined(e.getReason()), 24, TimeUnit.HOURS);
            circuitBreaker.recordSuccess(); // Not a system failure
            return PaymentResult.declined(e.getReason());
        }
    }
}

// io.thecodeforge — System Design tutorial

// Waiting room queue management using Redis sorted set

public class WaitingRoom {
    private final Jedis jedis;
    private final int admissionRatePerMinute = 10000;

    public void enqueueUser(String userId, String eventId) {
        String key = "waitingroom:" + eventId;
        long now = System.currentTimeMillis();
        jedis.zadd(key, now, userId);
        // Set TTL to 1 hour to clean up abandoned users
        jedis.expire(key, 3600);
    }

    public String getQueuePosition(String userId, String eventId) {
        String key = "waitingroom:" + eventId;
        Long rank = jedis.zrank(key, userId);
        if (rank == null) return null;
        return String.valueOf(rank + 1);
    }

    public void admitUsers(String eventId) {
        String key = "waitingroom:" + eventId;
        // Admit users in batches every second (roughly 167 per second for 10k/min)
        Set<String> users = jedis.zpopmin(key, admissionRatePerMinute / 60);
        for (String userId : users) {
            String tokenKey = "token:" + eventId + ":" + userId;
            String token = UUID.randomUUID().toString();
            jedis.setex(tokenKey, 30, token); // token expires in 30 seconds
            // Notify user via WebSocket or push
            NotificationService.notifyUser(userId, token);
        }
    }
}

// io.thecodeforge — System Design tutorial

// Prometheus metrics for the ticketing system

# HELP ticket_reservations_total Total number of seat reservations
# TYPE ticket_reservations_total counter
ticket_reservations_total{event="tswift2025", status="success"} 50000
ticket_reservations_total{event="tswift2025", status="failure"} 1200

# HELP ticket_reservation_duration_seconds Duration of seat reservation
# TYPE ticket_reservation_duration_seconds histogram
ticket_reservation_duration_seconds_bucket{le="0.1"} 45000
ticket_reservation_duration_seconds_bucket{le="0.5"} 49000
ticket_reservation_duration_seconds_bucket{le="1.0"} 50000
ticket_reservation_duration_seconds_sum 2500
ticket_reservation_duration_seconds_count 50000

# HELP order_queue_depth Current depth of order processing queue
# TYPE order_queue_depth gauge
order_queue_depth{queue="orders"} 1500

# HELP payment_gateway_error_rate Error rate for payment gateway calls
# TYPE payment_gateway_error_rate gauge
payment_gateway_error_rate{gateway="stripe"} 0.02