Project overview
We built an online system for a small airline to centralize daily operations and provide a reliable booking experience for customers.
Customer experience: create accounts, search flights by date and location, book and cancel reservations, and track travel history with timely confirmations and updates.
Operations experience: employees (pilots/flight attendants) access dashboards listing assigned flights; booking managers manage schedules (add/remove/delay flights), assign crew, and oversee booking activity; the owner/admin gets a centralized dashboard to manage employees, monitor customer activity, and update airline-wide content (policies, announcements, promotions).
Requirements, model, persistence foundation
Defined the system scope with a requirements backlog: 15 requirements total (10 functional + 5 non-functional) tracked in GitHub Issues/Projects for traceability.
Created use case diagrams tied to key actors and selected six use cases for full use-case specifications (each owned by a team member).
Designed the domain model as a UML class diagram and translated it into a persistence layer backed by PostgreSQL.
Validated the persistence layer with a comprehensive test suite covering read/write operations to ensure entities + relationships behave correctly before building services on top.
Set up a Gradle build system to automate compilation, testing, and packaging so the project builds consistently across the team.
Backend services, business logic, REST APIs
Implemented all use cases as business methods in a clean service layer and exposed them through RESTful HTTP endpoints in Spring Boot (GET/POST/PUT/DELETE).
Organized the backend into controllers, services, DTOs, repositories, and entities to keep responsibilities clear: controllers handle HTTP contracts, services enforce business rules, repositories handle persistence, and DTOs keep API payloads stable.
Extended the Deliverable 1 persistence layer as needed to support new operations (searching, booking flows, role actions, and admin/manager tools).
Built a strong testing suite using JUnit + Mockito, including both unit tests (mocking dependencies to test service behavior) and integration tests (validating REST endpoints and database interaction).
Documented testing strategy and coverage expectations in a Software Quality Assurance plan/report to ensure reliability and consistent QA across features.
Frontend UI + full integration
Built a complete web frontend using HTML/CSS/JavaScript with a consistent layout system across roles (shared base pages + role-specific dashboards).
Integrated the frontend with the backend through asynchronous REST API calls so users interact with real persisted data (no static mocks).
Implemented role-specific pages and flows: customers can search flights, book/cancel, and view history; employees can view assigned flights; managers/admin can manage schedules, crew assignments, policies, and promotions through UI workflows connected to real endpoints.
Maintained a build pipeline to package the application reliably and ensured project documentation and decisions (meeting minutes, wiki) were kept up to date for long-term maintainability.
Architecture
Database: PostgreSQL persistence for the full domain model, including users/roles and airline operations entities like flights, bookings, crew assignments, airports, policies, payments, cancellations, and promotions.
Backend: Spring Boot REST API with a layered design (controllers → services → repositories). Business logic lives in services (validation, constraints, workflow correctness), and DTOs define clean API contracts for the frontend.
Frontend: HTML/CSS/JS multi-role UI. Pages call the REST API asynchronously, render results, handle empty/error states, and keep the displayed state aligned with backend truth after every mutation (create/update/delete/cancel).
Quality & DevOps: Gradle build automation + a structured GitHub backlog (issues, assignments, meeting minutes) to keep work traceable and reproducible.
What I contributed
Deliverable 1: contributed to functional/non-functional requirements, domain model design, use case diagram design, wrote 1 of the 6 use case specifications, and helped validate persistence through JPA testing.
Deliverable 2: defined HTTP request methods (GET/POST/PUT/DELETE) for Admin and SpecialPromotion, and implemented the full Controller + Service + DTOs + Unit Tests + Integration Tests for User and Role using JUnit + Mockito.
Deliverable 3: built customer-facing frontend pages (4 pages) and contributed to the presentation by demonstrating a delivered feature plus proposed future features, ensuring the UI was correctly wired to backend endpoints and reflected real database state.
Results
Delivered a complete end-to-end airline system where customers can register, search flights by date/location, book and cancel reservations, and view travel history, all backed by persistent database state.
Enabled operational efficiency with role-based dashboards for employees, booking managers, and the owner/admin, reducing manual coordination by centralizing schedules, assignments, and airline-wide content updates.
Achieved strong reliability through systematic testing: unit tests with Mockito to isolate business logic, plus integration tests to validate REST endpoints and database persistence under real workflows.
What I'd do next
Add real authentication/authorization (JWT + role-based access control) to fully secure admin/manager operations and protect user data.
Improve robustness under concurrency: transactional booking with race-condition protection (e.g., seat availability conflicts) and standardized error DTOs for consistent frontend handling.
Expand product usability: richer flight search (sorting, pagination, multi-leg filters), stronger confirmation/notification flows, and better audit/logging for operational actions.
Raise QA further with CI (automated test runs on PRs), coverage reporting, and more end-to-end UI tests for critical workflows (search → book → cancel → history).