✈️ Airline Booking Platform — Full Stack (Microservices + Android)

A distributed, event-driven backend system for flight management, booking orchestration, and automated notifications — paired with a premium Jetpack Compose Android client.

Built with Node.js, Express, MySQL, RabbitMQ, and Kotlin (Jetpack Compose). Deployed on AWS using a custom API Gateway and Auto Scaling Groups.

📱 Android App

Download & Try (Static UI Preview APK)

This APK demonstrates the full UI/UX with static mock data. No backend required.

⬇️ Download APK (Google Drive)

Android Source Code

📦 Android App Repository — GitHub

Install the APK on Your Android Device

Open the Google Drive link above on your Android phone and tap Download
Once downloaded, tap the .apk file in your notifications or file manager
If prompted, go to Settings → Security → Install unknown apps and enable it for your browser/file manager
Tap Install and open the app
Note: This APK uses static mock data. To use live booking with the real backend, build from source (see Run the Android App below)

🔗 Microservice Repositories

Service	Responsibility	Repository
API Gateway	Central entry point, Routing, Rate Limiting, Auth Proxy	Link
Auth Service	JWT issuance, Validation, User Management	Link
Flight Service	Flight Catalog, City/Airport Management, Search Filters	Link
Booking Service	Booking Orchestration, Transaction Management, Message Publishing	Link
Reminder Service	Cron Jobs, Email Notifications, RabbitMQ Consumer	Link

📖 Project Overview

This is a comprehensive Airline Booking System built using a Microservices Architecture. It simulates a real-world production environment where different functionalities (Authentication, Booking, Flight Search, Notifications) are decoupled into independent services.

The system handles the complete flow of a flight reservation — from searching for flights and managing seat inventory, to processing secure bookings and sending asynchronous email notifications — all accessible through a polished Android mobile client.

✨ Key Features

📱 Android App Features

JWT Authentication — Login & signup with role selection (Passenger / Admin); session persisted in SharedPreferences
Live Flight Search — Real airport dropdowns from API; filtered by departure airport, arrival airport, and travel date (timezone-aware)
Premium Flight Cards — Airline branding, flight duration, seat availability indicator, price per seat
Booking Flow — Seat selector, real-time booking creation, success/error dialogs; triggers confirmation email via RabbitMQ
My Bookings — Boarding-pass style cards split into Upcoming and Previous tabs, sorted by departure time
User Profile — Displays real JWT-decoded email and role
Admin Panel — Full flight and airport CRUD management
Custom UI — Wave-shaped curved bottom nav with raised FAB; all times shown in device local timezone

👤 Backend Features (User-Facing)

Smart Flight Search — Filter by source, destination, and price range
Real-Time Seat Availability — Atomic seat inventory update prevents overbooking
Secure Authentication — JWT + bcrypt password hashing
Instant Booking Confirmation — Email sent immediately after booking
Automated Reminders — Cron job sends flight reminder emails 24 hours before departure

⚙️ Backend Features (Technical)

Centralized API Gateway — Single entry point for routing, rate limiting, and logging
Event-Driven Architecture — RabbitMQ decouples booking from notifications for low latency
Resilient Scheduling — Reminder Service handles scheduling even if mail server is temporarily down
Scalable Infrastructure — AWS Auto Scaling Groups + Load Balancers for traffic spikes

🏗️ System Architecture

Android App (Jetpack Compose)
        │
        ▼
  API Gateway :3005
  ┌─────────────────────────────────┐
  │  Auth Service       :7000       │
  │  Flight Service     :3000       │
  │  Booking Service    :5000  ──── RabbitMQ ──── Reminder Service :3004
  └─────────────────────────────────┘                    │
        │                                           Nodemailer (Email)
     MySQL / AWS RDS

Key Workflows:

Search: App → Gateway → Flight Service (MySQL)
Booking: App → Gateway → Booking Service → Flight Service (seat check) → MySQL (save)
Notification: Booking Service → RabbitMQ → Reminder Service → Nodemailer

🛠️ Full Tech Stack

Android App

Layer	Technology
Language	Kotlin
UI	Jetpack Compose (Material 3)
Navigation	Compose Navigation (`androidx.navigation`)
Dependency Injection	Dagger Hilt (`@HiltViewModel`, `@Singleton`)
Networking	Retrofit 2 + OkHttp (with `AuthInterceptor` for JWT)
Serialization	Gson (`@SerializedName`)
State Management	Kotlin `StateFlow` / `MutableStateFlow`
Auth	JWT decoded from SharedPreferences
Date/Time	`java.time` (API 26+): `Instant`, `ZoneId`, `LocalDate`
Min SDK	API 26 (Android 8.0)

Backend

Layer	Technology
Runtime	Node.js
Framework	Express.js
Database	MySQL + Sequelize ORM
Cloud DB	AWS RDS
Message Broker	RabbitMQ (`amqplib`)
Task Scheduling	node-cron
Email	Nodemailer
Auth	JWT + bcrypt
Logging	Morgan
Cloud Infra	AWS EC2, Auto Scaling Groups, ALB

🚀 How to Run the Full Stack Locally

Prerequisites

Node.js (v18+)
MySQL Server running locally
RabbitMQ running locally (amqp://localhost)
Android Studio Hedgehog or newer (for the app)
JDK 17+, Android SDK API 26+

Step 1 — Clone All Repositories

Create a root folder and clone each service into it:

mkdir AirlineBookingProject && cd AirlineBookingProject

# 1. API Gateway
git clone https://github.com/rkt0209/ApiGateway

# 2. Auth Service
git clone https://github.com/rkt0209/Auth_Service

# 3. Flight & Search Service
git clone https://github.com/rkt0209/flightsandSearch

# 4. Booking Service
git clone https://github.com/rkt0209/bookingService

# 5. Reminder Service
git clone https://github.com/rkt0209/reminderService

# 6. Android App
git clone https://github.com/rkt0209/airlineManagmentAPP

Step 2 — Database Setup

Create the three databases in your local MySQL:

CREATE DATABASE auth_db;
CREATE DATABASE booking_db;
CREATE DATABASE flights_search_db;

Step 3 — Configure Each Service

3a. Database Config (`src/config/config.json`)

Create config.json inside each service's src/config/ folder:

{
  "development": {
    "username": "root",
    "password": "YOUR_MYSQL_PASSWORD",
    "database": "SERVICE_DB_NAME",
    "host": "127.0.0.1",
    "dialect": "mysql"
  }
}

Service	`"database"` value
Auth Service	`"auth_db"`
Booking Service	`"booking_db"`
Reminder Service	`"booking_db"`
Flight Service	`"flights_search_db"`

3b. Environment Variables (`.env`)

Create a .env file in the root of each service folder:

API Gateway

PORT=3005
AUTH_SERVICE=http://localhost:7000
BOOKING_SERVICE=http://localhost:5000
FLIGHT_SERVICE=http://localhost:3000

Auth Service

PORT=7000
SALT=YourRandomSaltString
JWT_KEY=YourSecretKey
DB_SYNC=true

Flight Search Service

PORT=3000
DB_SYNC=true

Booking Service

PORT=5000
DB_SYNC=false
FLIGHT_SERVICE_PATH=http://localhost:3000/flightservice
USER_SERVICE_PATH=http://localhost:7000/authservice
MESSAGE_BROKER_URL=amqp://localhost
EXCHANGE_NAME=AIRLINE_BOOKING
REMINDER_BINDING_KEY=REMINDER_SERVICE

Reminder Service

PORT=3004
EMAIL_ID=your-email@gmail.com
EMAIL_PASS=your-gmail-app-password
MESSAGE_BROKER_URL=amqp://localhost
EXCHANGE_NAME=AIRLINE_BOOKING
REMINDER_BINDING_KEY=REMINDER_SERVICE

For EMAIL_PASS: use a Gmail App Password (not your account password). Generate one at Google Account → Security → 2-Step Verification → App Passwords.

Step 4 — Install, Migrate & Start Each Service

Open 5 separate terminals and run in this order:

# 1. Auth Service
cd Auth_Service && npm install && npx sequelize db:migrate && npm start

# 2. Flight Service
cd flightsandSearch && npm install && npx sequelize db:migrate && npm start

# 3. Reminder Service
cd reminderService && npm install && npx sequelize db:migrate && npm start

# 4. Booking Service
cd bookingService && npm install && npx sequelize db:migrate && npm start

# 5. API Gateway (last — depends on all other services)
cd ApiGateway && npm install && npm start

Startup order matters: RabbitMQ and MySQL must be running before any service. API Gateway must start last.

The backend is now live at: http://localhost:3005

📱 Run the Android App from Source

Step 1 — Open in Android Studio

Launch Android Studio
File → Open → select the airlineManagmentAPP/ folder
Wait for Gradle sync to complete

Step 2 — Configure the Backend URL

The app defaults to http://10.0.2.2:3005 — the Android emulator's loopback address for your host machine.

Scenario	What to do
Running on emulator	No change needed — `10.0.2.2` works out of the box
Running on a physical device	Open `app/src/main/java/com/example/airline/core/network/NetworkModule.kt` and replace `10.0.2.2` with your machine's local IP (e.g., `192.168.1.5`)

Your phone and computer must be on the same Wi-Fi network.

Step 3 — Build & Run

Select an emulator or connected device (API 26+)
Click Run ▶ or press Shift + F10
The app will launch and connect to your running backend

📲 Install the Live-Connected APK (Build from Source)

If you want to share the app with someone who already has the backend running:

In Android Studio: Build → Build Bundle(s) / APK(s) → Build APK(s)

APK is generated at:

airlineManagmentAPP/app/build/outputs/apk/debug/app-debug.apk

Transfer the APK to the target Android device (USB, Google Drive, etc.)
On the device: Settings → Security → Install unknown apps → enable for your file manager
Tap the APK file and install
Ensure the device is on the same network as the backend, or point to a deployed backend URL

☁️ How to Deploy on AWS

Deployment Overview

Hardware: t2.micro / t2.medium EC2 instances
OS: Ubuntu 24.04 LTS
Database: AWS RDS (MySQL)
Scaling: AWS Auto Scaling Group (ASG) behind an Application Load Balancer (ALB)

Step-by-Step Guide

RDS Setup: Create a MySQL instance on AWS RDS
Launch Template: Create an EC2 Launch Template using the User Data Script in aws/launch-script.sh

Update the DB_HOST variable in the script with your RDS Endpoint
Auto Scaling: Create an Auto Scaling Group using the template
Load Balancer: Attach an Application Load Balancer (Internet Facing) listening on Port 80
Target Group: Point the Load Balancer to Port 3005 (the API Gateway)
Android App (Cloud): Update NetworkModule.kt with the Load Balancer DNS and rebuild the APK

Accessing the Deployed API

GET  http://<LOAD_BALANCER_DNS>/home
POST http://<LOAD_BALANCER_DNS>/flightservice/api/v1/flights

📂 Backend Project Structure

/config       — Environment configs and DB connections
/controllers  — HTTP request/response handlers
/services     — Core business logic
/repository   — Data Access Layer (DB queries)
/models       — Sequelize schema definitions
/migrations   — Database schema version control
/seeders      — Initial data population scripts
/middlewares  — Auth checks, validation, error handling
/routes       — API route definitions
/utils        — Helper functions and error classes

📄 License

This project is for educational and portfolio purposes.

Name		Name	Last commit message	Last commit date
aws		aws
workflow		workflow
README.md		README.md

Latest commit

History

Folders and files

Repository files navigation