How to Design a Ticket Booking System: Architecture & Best Practices

To design a ticket booking system, create components like user interface, booking service, inventory management, and payment gateway. Use database transactions and locking mechanisms to prevent double booking and ensure data consistency.

Syntax

A ticket booking system typically includes these parts:

• User Interface: Where users select tickets and enter details.
• Booking Service: Handles booking requests and business logic.
• Inventory Management: Tracks available tickets and updates counts.
• Payment Gateway: Processes payments securely.
• Database: Stores user, booking, and ticket data with transaction support.

Use ACID transactions in the database to keep data consistent and locking or optimistic concurrency control to avoid double booking.

javascript

class TicketBookingSystem {
    constructor() {
        this.availableTickets = 100;
        this.bookings = [];
    }

    bookTicket(userId, ticketCount) {
        if (this.availableTickets >= ticketCount) {
            this.availableTickets -= ticketCount;
            this.bookings.push({ userId, ticketCount });
            return 'Booking successful';
        } else {
            return 'Not enough tickets';
        }
    }
}

Example

This example shows a simple booking system that checks ticket availability and books tickets if possible.

javascript

class TicketBookingSystem {
    constructor() {
        this.availableTickets = 5;
        this.bookings = [];
    }

    bookTicket(userId, ticketCount) {
        if (this.availableTickets >= ticketCount) {
            this.availableTickets -= ticketCount;
            this.bookings.push({ userId, ticketCount });
            return `Booking successful for user ${userId}`;
        } else {
            return `Not enough tickets for user ${userId}`;
        }
    }
}

const system = new TicketBookingSystem();
console.log(system.bookTicket('user1', 3));
console.log(system.bookTicket('user2', 3));
console.log(system.bookTicket('user3', 1));

Output

Booking successful for user user1
Not enough tickets for user user2
Booking successful for user user3

Common Pitfalls

Common mistakes when designing ticket booking systems include:

• Not handling concurrent bookings properly, causing double booking.
• Ignoring transaction management, leading to inconsistent data.
• Failing to update ticket inventory atomically.
• Not validating payment before confirming booking.

Use database transactions and locking to avoid these issues.

javascript

/* Wrong approach: No concurrency control */
function bookTicketWrong(system, userId, count) {
    if (system.availableTickets >= count) {
        // Delay simulates concurrent access
        setTimeout(() => {
            system.availableTickets -= count;
            console.log(`Booked ${count} tickets for ${userId}`);
        }, 100);
    } else {
        console.log(`Not enough tickets for ${userId}`);
    }
}

/* Right approach: Use locking or transactions (conceptual) */
async function bookTicketRight(system, userId, count) {
    await lock.acquire('booking', async () => {
        if (system.availableTickets >= count) {
            system.availableTickets -= count;
            console.log(`Booked ${count} tickets for ${userId}`);
        } else {
            console.log(`Not enough tickets for ${userId}`);
        }
    });
}

Quick Reference

• Use ACID transactions to keep booking data consistent.
• Implement locking or optimistic concurrency to prevent double booking.
• Separate services for UI, booking logic, inventory, and payment.
• Validate payments before confirming bookings.
• Scale with caching and load balancers for high traffic.

Key Takeaways

Use database transactions and locking to prevent double booking.

Separate system components for clear responsibilities and scalability.

Always validate payment before confirming a booking.

Handle concurrency carefully to maintain data consistency.

Design for scalability with caching and load balancing.