Airbnb-Clone - HotelManagement&Booking System

Overview

Airbnb Clone is a backend Hotel Management and Booking System built with Java and Spring Boot, providing secure RESTful APIs for authentication, hotel and room management, and customer bookings. It uses JWT-based authentication with role-based authorization for Admin, Hotel Owner, and Customer users, PostgreSQL with JPA/Hibernate for relational data, and Stripe for payment processing. The system validates room availability to prevent overlapping reservations and double bookings, follows a layered Controller-Service-Repository architecture, and is containerized with Docker for consistent deployment.

Live at Airbnb.saiifbaba - docs and the full command reference. Published on npm.

Problem Statement

Hotel and room booking systems need to handle multiple users, hotel owners, room inventory, availability, reservations, authentication, and payments while preventing conflicting bookings.

The goal of this project was to build a production-style backend that manages the complete booking lifecycle securely and reliably.

Room Availability & Double-Booking Prevention

The booking workflow validates room availability before creating a reservation. Date ranges are checked against existing bookings so overlapping reservations for the same room cannot be created:

public boolean isRoomAvailable(Room room, LocalDate checkIn, LocalDate checkOut) {
  return bookingRepository
      .findOverlappingBookings(room.getId(), checkIn, checkOut)
      .isEmpty();
}

• Check-in and check-out dates are validated before any booking is persisted
• Existing reservations are queried for date overlap rather than only matching exact dates
• Booking creation and payment state are kept consistent throughout the workflow

Secure Role-Based Access

The API uses JWT authentication and role-based authorization to protect user and hotel operations. Each request is authenticated before reaching the service layer, and permissions are applied according to the user's role.

• Admin: manages users, hotels, rooms, and platform-level operations
• Hotel Owner: manages owned hotels, rooms, pricing, and availability
• Customer: searches rooms, creates bookings, and manages personal reservations

Hotel and Room Management

Hotel owners can create and update hotels, add rooms, define room details, and manage availability. Customers can browse available rooms and submit booking requests using the same REST API.

The layered design keeps controllers focused on HTTP requests, services responsible for business rules, and repositories responsible for PostgreSQL data access.

Payment Processing with Stripe

Stripe is integrated into the booking flow so payment status is tracked alongside reservation state. A booking is not treated as successfully paid until the payment operation has been completed and validated.

This separation makes failed or incomplete payments visible and prevents the system from presenting an unpaid reservation as confirmed.

REST API and Layered Architecture

The same backend structure supports authentication, hotel management, room availability, booking, and payment operations:

@PostMapping("/bookings")
public ResponseEntity<Booking> createBooking(@RequestBody BookingRequest request) {
  return ResponseEntity.ok(bookingService.createBooking(request));
}

• Controller layer: exposes REST endpoints and validates incoming requests
• Service layer: applies booking, authorization, availability, and payment rules
• Repository layer: persists and queries entities through JPA and Hibernate

Tech Stack

Challenges & Trade-offs

• Preventing double bookings. Availability checks had to handle overlapping date ranges reliably instead of checking only whether a room was already reserved on one date.
• Maintaining entity relationships. Users, hotels, rooms, and bookings require carefully designed JPA relationships to keep data consistent as records are created and updated.
• Payment and booking consistency. Stripe payment status must remain synchronized with booking state when payments succeed, fail, or are abandoned.
• Balancing security and usability. Role-based access protects management operations while keeping the customer booking flow straightforward.
• Containerized deployment. Docker packages the backend and its runtime dependencies consistently across development and deployment environments.

What I Learned

• Secure API design - building JWT authentication and role-based authorization with Spring Security
• Layered backend architecture - separating controllers, services, and repositories to keep business logic maintainable
• Relational data modeling - designing PostgreSQL entities and JPA relationships for a real-world booking domain
• Availability algorithms - validating date ranges and preventing overlapping room reservations
• Payment workflows - integrating Stripe while keeping payment and booking states reliable
• API testing - validating authentication, authorization, booking, availability, and payment scenarios with Postman

Impact

• Complete booking lifecycle - supports authentication, hotel and room management, availability, reservations, and payments
• Safer reservations - prevents overlapping bookings through date-range validation
• Role-aware operations - gives Admin, Hotel Owner, and Customer users appropriate access to the platform
• Production-ready foundation - combines PostgreSQL, JWT, Stripe, and Docker in a clean Spring Boot backend