BETHANY NAVAJEEVAN SENIOR SECONDARY SCHOOL

Affiliated to CBSE Board, Affiliation No: 1931074

BETHANY NAGAR, VENCODE, CODE 55988

ACADEMIC YEAR 2025-2026

PROJECT REPORT ON

“AIRPORT MANAGEMENT SYSTEM”

REGISTER NO. :

NAME : BETSALEL B A

GRADE & DIVISION : XI JASMINE

SUBJECT : COMPUTER SCIENCE

SUBJECT CODE : 083

 BETHANYNAVAJEEVAN SENIOR SECONDARY SCHOOL

Affiliated to CBSE Board, Affiliation No: 1931074

BETHANY NAGAR, VENCODE

DEPARTMENT OF COMPUTER SCIENCE

CERTIFICATE

“This is to certify that BETSALEL B A, a student of Grade XI Jasmine, has

successfully completed the project work entitled ‘AIRPORT
MANAGEMENT SYSTEM’in the subject of Computer Science (083) under
the guidance of [Link] D M.E.,[Link]. during the academic year 2025-
2026, for the purpose of the Practical Examination conducted by AISSCE, New
Delhi."

Name of the Examiner Name of the Subject Teacher

Signature of the Examiner Signature of the Subject Teacher

Signature of the Principal

1
 STUDENT DECLARATION

I, BETSALEL B A, hereby declare that the project report entitled ‘AIRPORT

MANAGEMENT SYSTEM’ submitted to Bethany Navajeevan Senior
Secondary School is an original work carried out by me under the guidance of
Mr. JAMES D M.E.,[Link]. This report is the result of my independent
research and effort and has not been previously submitted for any examination
or assessment. It is submitted for the Practical Examination conducted by
AISSCE, New Delhi, during the academic year 2025-2026

Date:
Place:

Signature of Candidate

2
 ACKNOWLEDGEMENT

I acknowledge the Lord Almighty for giving me knowledge and strength

to complete this project.

I extend my deep sense of gratitude and sincere thanks to our Correspondent

[Link]. THOMAS REGI OIC and Principal [Link]. SIJO THOMAS OIC,
Bethany group of Institutions for giving me an opportunity to be a student of
this reputed institution.

I would like to extend my sincere appreciation to our Vice Principal, Mr.

FRANCIS EBANEZER, for his invaluable support and guidance throughout
this project.

I extend my respect to our Academic Mentor Mr. SIBIN JOSE, M.A.,

[Link]. for his valuable support in carrying my project work.

I also express my sense of gratitude to my Project Guide Mr. JAMES

D,M.E.,[Link] his valuable suggestion and guidance for doing this project.

I also express my gratitude to all the faculty members, parents and my

dear friends who have helped me to carry out this work.

3
 TABLE OF CONTENTS

[Link]. TOPIC PAGE NO.

1. ABSTRACT 5

2. OBJECTIVES 6

3. INTRODUCTION 7

4. PROJECT REQUIREMENTS 8

5. EXISTING SYSTEM 10

6. PROPOSED SYSTEM 11

7. SOURCE CODE 14

8. OUTPUT 22

9. CONCLUSION 25

10. BIBLIOGRAPHY 26

4
 ABSTRACT

The Airport Management System is a database-driven software application

designed to efficiently manage and automate the core operations of an airport.
With the rapid growth of air travel, manual handling of flight schedules,
passenger records, and bookings has become inefficient and error-prone. This
project aims to provide a structured, computerized solution to overcome these
challenges by integrating Python (Tkinter) for the graphical user interface and
MySQL for backend database management.

The system is divided into three main modules: Flights, Passengers, and
Bookings. The Flights module manages flight details such as flight name,
source, destination, departure and arrival times, aircraft type, seat capacity,
flight status, and gate number. The Passengers module stores passenger
information including name, age, gender, and contact details. The Bookings
module establishes a relationship between passengers and flights using unique
IDs, ensuring data consistency and relational integrity.

A user-friendly and vibrant graphical interface is developed using the

Tkinter module, making the system easy to use even for non-technical users.
The application allows users to add, view, and manage records efficiently while
minimizing redundancy and human errors. MySQL ensures secure storage, fast
retrieval, and proper organization of large datasets.

5
 OBJECTIVES
The main objective of the Airport Management System project is to
develop a computerized application that simplifies and automates the
management of airport operations. Traditional airport data handling methods
involve extensive paperwork and manual processes, which are time-consuming
and prone to errors. This project aims to replace such methods with a reliable,
efficient, and user-friendly software solution.

The detailed objectives of the project are as follows:

1. To design and implement an automated airport management system

that handles essential operations such as flight scheduling, passenger data
management, and flight bookings in an organized manner.
2. To develop an interactive and visually appealing graphical user
interface (GUI) using Python’s Tkinter module, ensuring ease of use,
better accessibility, and improved user experience.
3. To create a secure and structured backend database using MySQL,
capable of storing, retrieving, and managing large volumes of airport-
related data efficiently.
4. To maintain data integrity and consistency by using primary keys,
foreign keys, and relational tables that properly link flights, passengers,
and bookings.
5. To reduce manual workload and operational delays by enabling quick
data entry, instant data retrieval, and easy record management.
6. To minimize human errors and data redundancy that commonly occur
in manual record-keeping systems.
7. To demonstrate real-world application of programming concepts,
including database connectivity, SQL queries, CRUD operations, and
GUI-based application development.

6
 INTRODUCTION

The Airport Management System is a software-based solution designed to

automate and simplify the management of airport-related activities. This project
focuses on the effective handling of flight details, passenger information, and
booking records using a computerized approach. By integrating Python
programming with a MySQL database, the system ensures accurate data
storage, quick retrieval, and secure management of information.

The application provides a graphical user interface (GUI) developed using

Python’s Tkinter module, which allows users to interact with the system
easily. The GUI is designed to be simple, visually appealing, and user-friendly,
making it accessible even to users with basic computer knowledge. Through this
interface, airport staff can add new flights, register passengers, and manage
bookings efficiently.

The backend of the system uses MySQL, a powerful relational database

management system, to store all records in a structured format. The database is
designed using relational principles, where different tables such as flights,
passengers, and bookings are connected using unique identifiers. This ensures
data consistency, eliminates redundancy, and maintains the integrity of the
system.

The Airport Management System not only improves operational efficiency but
also reduces human errors associated with manual data handling. It provides
faster processing, better organization of data, and improved accuracy. The
modular design of the system makes it flexible and scalable, allowing future
enhancements such as online ticket booking, real-time flight status updates, staff
management, and payment integration.

7
 PROJECT REQUIREMENTS

The successful development and implementation of the Airport Management

System require a combination of appropriate hardware, software, database, and
user requirements. These requirements ensure that the system functions
efficiently, reliably, and meets the objectives of airport data management.

1. Hardware Requirements
The system does not require high-end hardware and can run efficiently on
standard personal computers. The minimum hardware requirements are as
follows:

 Processor: Intel Core i3 or equivalent (or higher)

 RAM: Minimum 4 GB
 Storage: At least 10 GB of free disk space
 Display: 1024 × 768 resolution or higher
 Input Devices: Keyboard and Mouse

2. Software Requirements
The following software components are required to develop and run the Airport
Management System:

 Operating System:

Windows 10 / Windows 11 / Linux / macOS

 Programming Language:

Python 3.8 or above

 GUI Module:

Tkinter (built-in Python module)

8
  Database Management System:

MySQL Server 8.0 or above

 Database Connector:

MySQL Connector for Python (mysql-connector-python)

 Code Editor / IDE:

VS Code / PyCharm / IDLE (any Python-supported IDE)

3. Database Requirements
The system uses a relational database to store and manage airport data. The
database requirements include:

 Creation of separate tables for:

o Flights
o Passengers
o Bookings
 Use of Primary Keys to uniquely identify each record
 Use of Foreign Keys to maintain relationships between tables
 Support for CRUD operations (Create, Read, Update, Delete)
 Proper handling of data types such as integers, strings, and timestamps

4. Functional Requirements
The functional requirements define what the system should do:

 Allow users to add, view, and manage flight details

 Allow users to register and manage passenger information
 Enable booking of flights using passenger and flight IDs
 Ensure data integrity through relational constraints

9
 EXISTING SYSTEM

In the existing system, airport management operations such as maintaining

flight schedules, passenger records, and booking details are largely handled
through manual or semi-computerized methods. Many small and medium-
scale airports rely on paper-based registers, spreadsheets, and disconnected
software tools to store and manage data. These methods are not efficient when
handling large volumes of information on a daily basis.

Flight information such as flight numbers, departure and arrival times, gate
assignments, and aircraft details are often recorded manually or maintained in
separate files. Passenger details are stored in registers or individual records
without proper linkage to flight data. Booking information is handled
separately, making it difficult to track which passenger is booked on which
flight. Due to the lack of a centralized database, retrieving or updating
information becomes a slow and complex process.

The existing system requires significant human effort to enter, update, and
verify data. As a result, it is highly prone to human errors such as incorrect
data entry, duplicate records, and data inconsistency. Searching for specific
flight or passenger information consumes a lot of time, especially during peak
travel hours. In case of changes or cancellations, updating records across
multiple files becomes tedious and unreliable.

Another major drawback of the existing system is the lack of data security and
backup mechanisms. Paper records can be lost, damaged, or misplaced, while
spreadsheet files can be accidentally deleted or corrupted. Additionally, the
existing system does not provide real-time validation or constraints, which may
lead to invalid or incomplete data entries.

10
 PROPOSED SYSTEM
The proposed Airport Management System is a fully automated, centralized,
and database-driven software application designed to overcome the limitations
of the existing manual and semi-computerized systems. The system integrates
Python programming with a MySQL relational database to provide an
efficient, accurate, and user-friendly solution for managing airport operations.

The proposed system is developed using a modular architecture, where each

major functionality is divided into independent yet interconnected modules.
This approach improves maintainability, scalability, and overall system
performance. The system focuses on three core operational areas: Flight
Management, Passenger Management, and Booking Management.

1. Centralized Database Management

The proposed system uses MySQL as the backend database to store all airport-
related data in a structured and organized manner. Separate relational tables are
created for flights, passengers, and bookings. Each table uses primary keys to
uniquely identify records and foreign keys to establish relationships between
them.

This centralized database ensures:

 Data consistency and integrity

 Elimination of data redundancy
 Faster data retrieval and updates
 Secure storage of critical information

2. Flight Management Module

The Flight Management module is designed to manage all flight-related
information efficiently. It allows authorized users to add, update, and view

11
flight details such as flight name, source, destination, departure and arrival
times, aircraft type, seat capacity, flight status, and gate number.

This module enables:

 Easy scheduling and modification of flight details

 Accurate tracking of flight status
 Efficient handling of aircraft and gate assignments
 Quick retrieval of flight information when required

3. Passenger Management Module

The Passenger Management module handles the registration and management
of passenger information. It stores essential passenger details such as name, age,
gender, and contact information. Each passenger is assigned a unique
passenger ID, which is used to link bookings with flights.

This module provides:

 Secure storage of passenger records

 Quick search and retrieval of passenger information
 Reduction of duplicate and incorrect entries
 Easy management of large numbers of passengers

4. Booking Management Module

The Booking Management module establishes a relationship between
passengers and flights using unique IDs. It allows users to book flights by
selecting existing passenger and flight records. This relational approach ensures
that bookings are accurate and valid.

This module supports:

 Error-free flight bookings

 Maintenance of referential integrity
12
  Easy tracking of passenger bookings
 Efficient handling of booking data

5. Graphical User Interface (GUI)

The proposed system features a graphical user interface developed using
Python’s Tkinter module. The GUI is designed with vibrant colors and a clean
layout to ensure ease of use and improved user experience. It allows users to
interact with the system without requiring technical knowledge.

The GUI provides:

 Simple data entry forms

 Clear navigation between modules
 Immediate feedback for user actions
 Improved accessibility and usability

6. Automation and Error Handling

The system automates most airport data management tasks, reducing the need
for manual intervention. Input validation and error handling mechanisms are
implemented to prevent invalid or incomplete data entries.

Key benefits include:

 Reduced human errors

 Improved data accuracy
 Faster processing of operations
 Reliable system performance

7. Scalability and Future Enhancements

The proposed system is designed to be scalable and flexible. New modules and
features can be added without affecting existing functionality.

13
 SOURCE CODE
import tkinter as tk
from tkinter import messagebox
import [Link]

# ---------------- DATABASE CONNECTION ----------------

def connect_db():
return [Link](
host="localhost",
user="root",
password="JJRAHUL", # change
database="airport_db"
)

# ================= LOGIN WINDOW =================

def login():
if [Link]() == "admin" and [Link]() == "admin@123":
login_window.destroy()
main_app()
else:
[Link]("Login Failed", "Invalid Username or Password")

login_window = [Link]()
login_window.title("Login")
login_window.geometry("400x300")
login_window.configure(bg="#ffdd59")

14
[Link](login_window, text="✈ Airport Management Login",
font=("Arial", 16, "bold"),
bg="#ffdd59", fg="#ff4757").pack(pady=20)

[Link](login_window, text="Username",
bg="#ffdd59", font=("Arial", 11)).pack()
username = [Link](login_window)
[Link](pady=5)

[Link](login_window, text="Password",
bg="#ffdd59", font=("Arial", 11)).pack()
password = [Link](login_window, show="*")
[Link](pady=5)

[Link](login_window, text="Login",
bg="#2ed573", fg="white",
font=("Arial", 11, "bold"),
command=login).pack(pady=20)

# ================= MAIN APPLICATION =================

def main_app():
root = [Link]()
[Link]("Airport Management System")
[Link]("900x600")
[Link](bg="#feca57")

15
 [Link](root, text="✈ Airport Management System",
font=("Arial", 22, "bold"),
bg="#feca57", fg="#ff4757").pack(pady=10)

# ---------------- TABS ----------------

tab_frame = [Link](root, bg="#feca57")
tab_frame.pack()

content = [Link](root, bg="#ffffff")

[Link](fill="both", expand=True)

# ---------------- FLIGHTS TAB ----------------

def flights_tab():
for widget in content.winfo_children():
[Link]()

[Link](content, text="✈ Flights",

font=("Arial", 16, "bold"),
bg="white").pack(pady=10)

form = [Link](content, bg="#70a1ff", bd=3)

[Link](pady=10)

labels = ["Flight Name", "Source", "Destination", "Departure Time",

"Arrival Time"]
entries = []

for i, text in enumerate(labels):

16
 [Link](form, text=text, bg="#70a1ff",
fg="white", font=("Arial", 11, "bold")).grid(row=i, column=0,
padx=10, pady=5)
e = [Link](form, width=25)
[Link](row=i, column=1, pady=5)
[Link](e)

def add_flight():
con = connect_db()
cur = [Link]()
[Link](
"INSERT INTO flights (flight_name, source, destination,
departure_time, arrival_time) VALUES (%s,%s,%s,%s,%s)",
tuple([Link]() for e in entries)
)
[Link]()
[Link]()
[Link]("Success", "Flight Added")

[Link](content, text="Add Flight",

bg="#2ed573", fg="white",
font=("Arial", 11, "bold"),
command=add_flight).pack(pady=10)

# ---------------- PASSENGERS TAB ----------------

def passengers_tab():
for widget in content.winfo_children():
[Link]()

17
 [Link](content, text="👤 Passengers",
font=("Arial", 16, "bold"),
bg="white").pack(pady=10)

form = [Link](content, bg="#1e90ff", bd=3)

[Link](pady=10)

labels = ["Name", "Age", "Gender"]

entries = []

for i, text in enumerate(labels):

[Link](form, text=text, bg="#1e90ff",
fg="white", font=("Arial", 11, "bold")).grid(row=i, column=0,
padx=10, pady=5)
e = [Link](form, width=25)
[Link](row=i, column=1, pady=5)
[Link](e)

def add_passenger():
con = connect_db()
cur = [Link]()
[Link](
"INSERT INTO passengers (name, age, gender) VALUES
(%s,%s,%s)",
(entries[0].get(), entries[1].get(), entries[2].get())
)
[Link]()

18
 [Link]()
[Link]("Success", "Passenger Added")

[Link](content, text="Add Passenger",

bg="#3742fa", fg="white",
font=("Arial", 11, "bold"),
command=add_passenger).pack(pady=10)

# ---------------- BOOKINGS TAB ----------------

def bookings_tab():
for widget in content.winfo_children():
[Link]()

[Link](content, text="🎫 Bookings",

font=("Arial", 16, "bold"),
bg="white").pack(pady=10)

form = [Link](content, bg="#ff7f50", bd=3)

[Link](pady=10)

[Link](form, text="Passenger ID", bg="#ff7f50",

fg="white", font=("Arial", 11, "bold")).grid(row=0, column=0,
padx=10, pady=5)
pid = [Link](form)
[Link](row=0, column=1)

[Link](form, text="Flight ID", bg="#ff7f50",

19
 fg="white", font=("Arial", 11, "bold")).grid(row=1, column=0,
padx=10, pady=5)
fid = [Link](form)
[Link](row=1, column=1)

def book():
con = connect_db()
cur = [Link]()
[Link](
"INSERT INTO bookings (passenger_id, flight_id) VALUES
(%s,%s)",
([Link](), [Link]())
)
[Link]()
[Link]()
[Link]("Success", "Booking Confirmed")

[Link](content, text="Book Flight",

bg="#2ed573", fg="white",
font=("Arial", 11, "bold"),
command=book).pack(pady=10)

# ---------------- TAB BUTTONS ----------------

[Link](tab_frame, text="✈ Flights", command=flights_tab,
bg="#70a1ff", fg="white", width=15).grid(row=0, column=0, padx=5)
[Link](tab_frame, text="👤 Passengers", command=passengers_tab,
bg="#1e90ff", fg="white", width=15).grid(row=0, column=1, padx=5)
[Link](tab_frame, text="🎫 Bookings", command=bookings_tab,

20
 bg="#ff7f50", fg="white", width=15).grid(row=0, column=2, padx=5)

flights_tab()
[Link]()

login_window.mainloop()

21
OUTPUT

22
23
24
 CONCLUSION
The Airport Management System successfully achieves its objective of
automating and simplifying airport data management operations. By replacing
traditional manual and semi-computerized methods with a centralized, database-
driven system, the project significantly improves efficiency, accuracy, and
reliability in handling airport-related information.

The integration of Python programming with a Tkinter-based graphical user

interface and a MySQL relational database provides a powerful yet user-
friendly solution for managing flight details, passenger information, and
bookings. The modular design of the system ensures smooth coordination
between different components while maintaining data integrity through proper
relational constraints.

The system minimizes human errors, reduces data redundancy, and enables
faster data retrieval and updates. Its visually appealing and intuitive interface
makes it accessible to users with basic computer knowledge. Moreover, the
scalable architecture allows future enhancements without major changes to the
existing structure.

25
 BIBLIOGRAPHY

Books

1. Elmasri, R. & Navathe, S. B. Fundamentals of Database Systems, 7th

Edition, Pearson Education, 2017.
2. Korth, H. F., Silberschatz, A., & Sudarshan, S. Database System
Concepts, 6th Edition, McGraw-Hill Education, 2019.
3. Lutz, Mark Learning Python, 5th Edition, O’Reilly Media, 2013.
4. Grayson, John E. Python and Tkinter Programming, Manning
Publications, 2016.
5. Date, C. J. An Introduction to Database Systems, 8th Edition, Pearson
Education, 2004.

Web Pages

1. Python Official Documentation

[Link]
2. MySQL Official Documentation
[Link]
3. Tkinter Module Documentation
[Link]
4. W3Schools – Python Tutorial
[Link]
5. W3Schools – MySQL Tutorial
[Link]
6. GeeksforGeeks – Python & DBMS Tutorials
[Link]

26