Design Ticket Booking for Concerts

Concert ticketing for flash on-sales, inspired by Ticketmaster and similar platforms: CDN event pages, atomic seat holds in memory, a virtual waiting room, background payment with hold expiry, and bot protection. A teaching design.

Functional requirements

  • Search available listings (hotels, flights, appointments) by criteria (date, location, category, price).
  • Display detailed availability: dates available, prices, capacity.
  • Reserve/hold a listing for a user during checkout (time-limited hold, e.g., 10 minutes).
  • Prevent double-booking: only one user can book the same slot/room/seat.
  • Process payment securely and verify before confirming booking.
  • Generate booking confirmations and send via email/SMS.
  • Support cancellations with refund policy (full, partial, non-refundable).
  • Enable modifications (date change, room upgrade) with repricing.

Non-functional requirements

  • Availability search: p99 < 200ms for millions of listings.
  • Booking confirmation: latency < 5 seconds including payment processing.
  • Prevent double-booking: 100% consistency for inventory (no concurrent overbooking).
  • Availability: 99.9%+; brief outages should queue bookings, not reject them.
  • Scalability: handle 10x spike during sales (flash deals, holidays) without degrading.
  • Data consistency: bookings are immutable; cancellations create reverse transactions.
  • Resilience: payment service down → queue booking for later; email service down → queue notification.

How the design evolves

Stage 1: Single Server Booking in the Database

See what a concert on-sale does to one server and one database.

What was missing: Nothing yet.

Why that's risky: At on-sale time hundreds of thousands of fans arrive in seconds; every page view, search and seat attempt hits one database, which locks up while scalper bots grab seats.

What gets added: One server that serves pages, searches and books seats in one database.

Trade-offs: Fine for a small venue, hopeless for a stadium tour.

Stage 2: Event Pages on a CDN and Search

Take everything that isn't buying a seat away from the database.

What was missing: Pages, search and booking all hit the same database.

Why that's risky: Every seat attempt is a database transaction on a handful of hot rows, so lock contention collapses throughput exactly when demand peaks.

What gets added: A CDN for event pages and static files, an event search service and index, and a booking service that takes a seat with a conditional update in the database.

Trade-offs: The search index shows remaining availability with a short delay.

Stage 3: Atomic Seat Holds in Memory

Absorb thousands of simultaneous seat grabs without locking database rows.

What was missing: Every seat attempt locked database rows.

Why that's risky: Every fan still hits the hold service at the same instant, and whoever has the fastest connection or script wins.

What gets added: An inventory cache where a hold is an atomic set-if-free with an 8-minute timer, a hold service in front of it, and a checkout service that turns a hold into a booking with a conditional update in the sharded inventory database.

Trade-offs: The cache is fast but not the source of truth: the database's conditional update on purchase is the final guard against overselling.

Stage 4: Virtual Waiting Room

Turn a stampede into an orderly line that admits fans at a rate the system can handle.

What was missing: Everyone hit seat selection at the same moment.

Why that's risky: Checkout still charges cards synchronously, and seats from abandoned checkouts aren't given back.

What gets added: A waiting room service: at on-sale everyone gets a random place in line, and fans are admitted at a fixed rate with a signed token that the hold service requires.

Trade-offs: Fans wait in line, sometimes for many minutes, in exchange for a site that stays up and a fair order.

Stage 5: Payment and Hold Expiry off the Hot Path

Charge reliably without blocking seats, and recycle abandoned holds.

What was missing: Charging blocked checkout, and abandoned holds never returned to sale.

Why that's risky: Bots can still hammer the waiting room and seat map, and nobody watches oversell checks or admission rate.

What gets added: Payment and ticketing jobs processed by workers that charge with an idempotency key and issue tickets, and delayed expiry jobs that release unpaid holds back to the line.

Trade-offs: Tickets arrive seconds after checkout instead of instantly.

Stage 6: Bot Protection and Observability

Keep scalper bots out and watch the on-sale live.

What was missing: Nothing distinguished bots from fans, and the on-sale was invisible.

Why that's risky: Remaining risk is account farms that look human; that needs verified-fan programs on top of rate limits.

What gets added: A bot shield with per-account and per-IP limits and challenges for suspicious clients, ticket limits per account, and monitoring of admission rate, line length, hold conversion, oversell checks and payment failures.

Trade-offs: Challenges add friction for some real fans.

PRISM
System Design Interview
Round 1 of 4 · Architecture Design · 60:00 remaining
PRISM logo
AI Interview
Interview Prep
Interview Challenges
Design Your Own System NEW
System Architectures
Design & Fix NEW
Interactive Roadmap System Design Guides
Notifications
  • No new notifications
Feedback
Signed in
Phase
Design Your Own System
Phase 01: Thinking in Systems
Upcoming

Components

User
CDN
Load Balancer
Server
Cache
Database
Blob Storage
Search Index
Queue
Worker
Rate Limiter
Service
API Gateway
Reverse Proxy
WebSocket Server
Third-party API

Inspector

Notes
Use clear names so your design intent is easy to understand.
Good
Name by business meaning
"Order API", "Restaurant Service"
Avoid
Generic names = zero signal
"Server 1", "API", "Queue"
A short description for each component makes feedback much better.
100%
Start by identifying:
  • Users & entry points
  • APIs & services
  • Databases & storage
  • Traffic flow & scale

Round 1 of 4 Architecture Design

Run a simulation to see results.

Time Remaining
60:00
System Design Interview

What are the core functional requirements?
What are the key non-functional constraints?

Questions

Start Evaluation to unlock questions.

Components Added
No components listed
Click "+ Add" to document components introduced in this stage.
Design Decisions

Click Simulate to run your design and see results here.

Internal notes — not shown to learners.

EVALUATE MODE

Test yourself like it's the real thing.

A structured 4-module evaluation that mirrors how top companies assess system design candidates.

Architecture Design
Draw your system on the canvas. Define components, connections, and data flow.
FR & NFR Requirements
Answer functional and non-functional requirement questions about your design.
MCQ Round
Multiple choice questions testing your depth on the chosen system.
Tradeoff Analysis
Justify your design decisions and defend your architectural tradeoffs.
AI Report Generated
A R S
Used by engineers preparing for FAANG & top-tier companies
Choose a Problem
No problem selected
  • 30 min
  • 45 min
  • 60 min
Round 2 of 4
MCQ Round
Answer multiple-choice questions based on your design.

Exit Interview?

You're in the middle of an interview session. Leaving now will end your current attempt.

Your progress will be saved.

Open a saved design

Select a design to load into the canvas.

My Evaluations

Your past evaluation sessions

Here’s a simple request flow that follows the expected layer order.

External User
→
Edge CDN → API Gateway → Load Balancer
→
Compute App Servers / Services
→
DataAccess Cache
→
Storage Database / Search Index
→
Async Queue → Worker

Tip: keep arrows moving forward through layers (Edge → Compute → Storage). Avoid sending storage back to compute.

Evaluation Instructions

Read the rules carefully before starting. The test auto-submits on refresh.

Before you start

  • Build your architecture on the canvas. The timer starts when you click Start Evaluation.
  • Don't forget to answer Functional Requirement and Non Functional Requirements.
  • When satisfied with your design, click Next to lock it and view the questions.
  • Please answer final step questions to complete the evaluation.

Dos

  • Do read each question carefully before answering.
  • Do include required components to maximize component coverage.
  • Do save a copy of your design if you want to keep it before submission.

Don'ts

  • Don't refresh or close the tab during an active evaluation — this will auto-submit your answers.
  • Don't switch app modes or open another tab while the evaluation is running.
  • Don't attempt to edit the design after clicking Next; the workspace will be locked.

All the best!!

Confirm

Input

Notice

Evaluation Report

Evaluation Complete

Generating Your Report

Hang tight — our AI is evaluating your design…

Did you know?

Loading…

Share feedback

Tell us what worked well and what we can improve.

Let's personalize this

Answer a couple of quick questions so we can tailor your journey and missions.

You can change this anytime from your Profile.

Your personalized missions are ready

We tailored these first steps based on your answers.

    PRISM Welcome Gift

    This is a personal welcome gift from PRISM.

    Congratulations.

    You explored PRISM.

    You earned Apprentice.

    As a welcome gift, unlock Full PRISM Access for the configured trial duration.

    This starts Trial. Trial timer begins only after you activate this gift.

    Welcome to PRISM

    We've prepared a personalized Apprentice Journey based on your goals and experience.

    This journey introduces you to the capabilities of PRISM that are most relevant to you.

    Complete all 8 missions to earn your Apprentice title. 8 MISSIONS

    PRISM Surprise Offer

    Complete your Apprentice Journey to unlock a special gift from PRISM.

    • No payment required
    • No credit card required
    • Just complete the journey
    MISSION CONTROL
    0 / 8 missions complete
    NEXT UP Continue your missions
    View full roadmap →
    Mission Complete 0 / 8 Completed Next: Keep going
    SYSTEM BRIEF

    ⬤ System Constraints

    What the system must do — every item is a user-facing behaviour your architecture must support.

      ↑ Engineering Constraints

      These are the failure modes you must design against — latency SLAs, durability targets, traffic ceilings.

        ⇆ Architecture Constraints

        ◈ Core Concepts to Master

        Your Journey
        PHASE – –
        0 / 0 0%
        0
        Mock Interview Checklist

        Pick a topic to start

        Explore concept overviews, real-system examples, key tradeoffs, and interview talking points for each roadmap section.

        Phase Mastered

        You've conquered this phase. These are the skills you now own:

          +500 XP

          Company Interview Paths

          Progress Summary