How to Design a Hotel Booking System: Architecture & Flow

To design a hotel booking system, create components like User Service, Hotel Inventory, Booking Service, and Payment Gateway. Use a flow where users search hotels, select rooms, book, and pay, ensuring availability checks and concurrency control to avoid double bookings.

Syntax

The main parts of a hotel booking system include:

• User Service: Manages user accounts and authentication.
• Hotel Inventory: Stores hotel details and room availability.
• Booking Service: Handles booking requests and confirms availability.
• Payment Gateway: Processes payments securely.
• Notification Service: Sends booking confirmations and updates.

These components communicate via APIs to handle requests smoothly.

javascript

class UserService {
    authenticate(user) { /* verify user credentials */ }
}

class HotelInventory {
    static checkAvailability(hotelId, roomType, dateRange) { /* return available rooms */ }
}

class BookingService {
    static createBooking(userId, hotelId, roomType, dateRange) {
        if (HotelInventory.checkAvailability(hotelId, roomType, dateRange)) {
            // reserve room and return booking confirmation
        } else {
            // return no availability
        }
    }
}

class PaymentGateway {
    processPayment(paymentDetails) { /* handle payment */ }
}

class NotificationService {
    sendConfirmation(bookingDetails) { /* notify user */ }
}

Example

This example shows a simple booking flow where a user searches for rooms, books if available, and pays.

javascript

class HotelInventory {
    constructor() {
        this.rooms = { 'hotel1': { 'single': 5, 'double': 3 } };
    }

    checkAvailability(hotelId, roomType) {
        return this.rooms[hotelId] && this.rooms[hotelId][roomType] > 0;
    }

    reserveRoom(hotelId, roomType) {
        if (this.checkAvailability(hotelId, roomType)) {
            this.rooms[hotelId][roomType] -= 1;
            return true;
        }
        return false;
    }
}

class BookingService {
    constructor(inventory) {
        this.inventory = inventory;
        this.bookings = [];
    }

    createBooking(userId, hotelId, roomType) {
        if (this.inventory.reserveRoom(hotelId, roomType)) {
            const booking = { userId, hotelId, roomType, status: 'confirmed' };
            this.bookings.push(booking);
            return booking;
        } else {
            return null;
        }
    }
}

// Usage
const inventory = new HotelInventory();
const bookingService = new BookingService(inventory);

const userId = 'user123';
const hotelId = 'hotel1';
const roomType = 'single';

const booking = bookingService.createBooking(userId, hotelId, roomType);
if (booking) {
    console.log('Booking confirmed:', booking);
} else {
    console.log('No rooms available');
}

Output

Booking confirmed: { userId: 'user123', hotelId: 'hotel1', roomType: 'single', status: 'confirmed' }

Common Pitfalls

Common mistakes when designing a hotel booking system include:

• Ignoring concurrency: Not handling simultaneous booking requests can cause double bookings.
• Not validating availability: Booking without checking room availability leads to errors.
• Poor payment handling: Not confirming payment before finalizing booking can cause inconsistencies.
• Lack of user notifications: Users may be confused without booking confirmations.

Use locking or transactions to prevent race conditions and always confirm payment before confirming bookings.

javascript

/* Wrong: Booking without availability check */
function createBookingWithoutCheck(hotelId, roomType) {
    // directly reserve room without checking
    // leads to overbooking
}

/* Right: Check availability before booking */
function createBookingWithCheck(hotelId, roomType, inventory) {
    if (inventory.checkAvailability(hotelId, roomType)) {
        inventory.reserveRoom(hotelId, roomType);
        // proceed with booking
    } else {
        // reject booking
    }
}

Quick Reference

• Use separate services for user management, inventory, booking, payment, and notifications.
• Always check room availability before booking.
• Handle concurrent booking requests with locks or transactions.
• Confirm payment before finalizing bookings.
• Send booking confirmation notifications to users.

Key Takeaways

Design modular services for user, inventory, booking, payment, and notifications.

Always check and reserve room availability to avoid double bookings.

Use concurrency control to handle simultaneous booking requests safely.

Confirm payment before completing the booking process.

Notify users with booking confirmations to improve experience.