EVENT TICKET MANAGEMENT SYSTEM

A PROJECT REPORT

submitted by

Surumy Sajeed
SCM24CS263
Vidhyasri Sreekumar
SCM24CS265
to

The APJ Abdul Kalam Technological University

in partial completion of the criteria for the degree award

of
B.Tech Degree
in
COMPUTER SCIENCE AND ENGINEERING

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

SCMS SCHOOL OF ENGINEERING AND TECHNOLOGY
(Affiliated to APJ Abdul Kalam Technological University)
VIDYA NAGAR, PALISSERY, KARUKUTTY
ERNAKULAM – 683582
October 2025
 DECLARATION

We undersigned hereby declare that the project report EVENT TICKET MANAGEMENT
SYSTEM, submitted for partial fulfilment of the requirements for the award of the degree of
Bachelor of Technology(CSE) of the APJ Abdul Kalam Technological University, Kerala is a
bonafide work done by me under the supervision of Ms Neethu Krishna. This submission
Net
represents our ideas in our own words and where ideas or words of others have been
included, we have adequately and accurately cited and referenced the sources. We also
declare that we have adhered to the ethics of academic honesty and integrity and have not
misrepresented or fabricated any data or idea or fact or source in my submission. We
understand that any violation of the above will be a cause for disciplinary action by the
institute and/or the University and can also evoke penal action from the sources which have
thus not been properly cited or from whom proper permission has not been obtained. This
report has not previously formed the basis for the award of any degree, diploma or similar
title of any other University.

Place:Ernakulum

Date: 7/10/2025
 DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

SCMS SCHOOL OF ENGINEERING AND TECHNOLOGY

Vidya Nagar, Karukutty, Kerala – 683 576

CERTIFICATE

This is to certify that the report entitled ENTRY LEVEL JOB PORTAL SYSTEM, submitted
by Devika R Krishna to the APJ Abdul Kalam Technological University in partial fulfilment of the
requirements for the award of the Degree of B.Tech in Computer Science and Engineering is a
bonafide record of the project work carried out by him/her under my/our guidance and supervision.
This report in any form has not been submitted to any other University or Institute for any purpose.

Project Co-ordinator Head of the Department

Ms. Neethu Krishna Dr.Manish T.I

Assistant Professor Professor

Department of CSE Department of CSE

SSET SSET
 ACKNOWLEDGEMENT

We are greatly indebted to Dr.Anitha G.Pillai, Principal, SCMS School of Engineering and
Technology, Ernakulam and Dr.Manish T.I, Professor and Head of Department, Department
of Computer Science and Engineering, SCMS School of Engineering and Technology, who
wholeheartedly permitted us to conduct this project.

We would like to thank our project co-ordinator, Ms.Neethu Krishna. Assistant Professor,
Department of Computer Science and Engineering, SCMS School of Engineering and
Technology who gave us valuable guidance. We would like to express sincere gratitude to all
the teachers of the Department of Computer Science who gave us moral and technical
support. We would like to thank the supporting staff in the computer lab whose dedicated
work kept the lab working smoothly thus enabling us to have access to various resources
which helped us understand more about the project topic. We would also like to extend our
gratitude to all friends and family for providing us with the necessary resources and support.
 ABSTRACT

The Event Ticket Management System is a standalone desktop application developed to simplify
and automate the process of event and venue management. The system allows users to register, log
in, and manage event details efficiently. Administrators can add, update, and delete event and venue
information through an intuitive interface, reducing manual work and ensuring organized data
storage.Developed using Java Swing for the front end and MySQL for the back end, the system
ensures reliability, security, and ease of use. All data is connected through JDBC, allowing seamless
communication between the user interface and the database.The project focuses on creating a
scalable, user-friendly solution that streamlines event organization tasks and provides a strong
foundation for future modules like ticket booking and payment integration.
 CONTENTS

Contents​ PageNo.

Acknowledgement​ i
Abstract​ ii
1.​ Chapter 1 - Introduction.......................................................................................8
1.1​Objective........................................................................................................9
2.​ Chapter 2 - Existing and Proposed System.........................................................10
2.1​ Existing System...........................................................................................10
2.2​ Proposed System......................................................................................... 10
2.3​ Methodology................................................................................................11
3.​ Chapter 3 - Implementation Details....................................................................13
3.1​ System Requirement Specification.............................................................13
3.2​ Platform and IDE.........................................................................................15
3.3​ Application Development and Implementation...........................................16
4.​ Chapter 4 - System Design.................................................................................17
5.​ Chapter 5 - Screen Shots.....................................................................................20
6.​ Chapter 6 - Conclusion........................................................................................25
7.​ References............................................................................................................26
 List of Figures

1.​ Figure 4.1 : System Architecture​ 17

2.​ Figure 5.1:Login/Register Options​ 20

3.​ Figure 5.2: Manage Events Page​ 21

4.​ Figure 5.3:Add event Page​ 22

5.​ Figure 5.4:Manage venues Page​ 22

6.​ Figure 5.5:Logout window​ 22

7.​ Figure 5.6: MySQL Database - Table Data​ 23

 Chapter 1
Introduction

Event management has become an essential aspect of modern life, covering a wide range of activities such
as conferences, workshops, concerts, exhibitions, and cultural programs. Traditionally, these events are
managed manually, where records are maintained using spreadsheets or paper-based systems. This manual
approach often results in errors, delays, data duplication, and difficulties in coordination, especially when
multiple events or venues are handled simultaneously.

With the increasing demand for digitization, automation of event management tasks has become a
necessity. The Event Ticket Management System aims to simplify and streamline this process by
providing a digital platform where users can efficiently manage events, venues, and related data. The
system automates the process of adding, updating, and deleting event records while storing all data
securely in a centralized database.

This system provides a graphical user interface built using Java Swing, allowing users to interact with the
application easily. It connects to a MySQL database using JDBC (Java Database Connectivity),
ensuring that data flows securely and efficiently between the application and storage. By combining Java’s
robust features and MySQL’s reliability, the system achieves a high level of accuracy, efficiency, and
user-friendliness.

The project not only demonstrates the practical application of Java and database integration but also
provides a foundation for future enhancements such as online ticket booking, automated payments, and
user-specific dashboards. Overall, the Event Ticket Management System serves as an effective solution to
replace manual event handling processes with an automated and reliable application

.
 1.1​OBJECTIVE

The primary objective of the Event Ticket Management System is to design and implement a
comprehensive software solution that simplifies event and venue management processes. The project aims
to automate repetitive tasks, minimize human errors, and ensure that event data is accurate, organized, and
easily accessible.

Specific objectives include:

1.​ To create a user-friendly graphical interface using Java Swing for managing events and venues.​

2.​ To design a secure login and registration module to authenticate users.​

3.​ To integrate a MySQL database for reliable data storage and retrieval.​

4.​ To implement full CRUD (Create, Read, Update, Delete) functionality for event and venue
records.​

5.​ To ensure data consistency and integrity through validated input and secure queries.​

6.​ To develop a modular system architecture that supports future extensions like ticket booking and
payment processing.​

7.​ To reduce manual paperwork and improve efficiency in managing multiple events simultaneously.​
 Chapter 2

Existing and Proposed System

2.1​Existing System

In the existing approach, event management activities are often performed manually. Event
organizers typically maintain data using spreadsheets, written records, or other offline tools. This
method is prone to a variety of issues:

●​ Difficulty in tracking large volumes of data.​

●​ High chances of human error during data entry or retrieval.​

●​ Lack of data security and centralized control.​

●​ Difficulty in updating event or venue details across multiple records.​

●​ Limited access to event data when multiple organizers are involved.​

These challenges lead to inefficiency and potential loss of important information. Moreover,
manual systems lack validation and error handling, which often causes duplication and
inconsistency in event details. As the number of events increases, the complexity of managing data
also grows.

The lack of automation and database integration results in unnecessary workload and reduced
productivity. Hence, there is a need for a digital, structured system that can automate the entire
process of event management and data handling.

2.2​Proposed System

The proposed Event Ticket Management System overcomes the limitations of the existing system by
introducing automation and database connectivity. The system is developed as a Java Swing desktop
application connected to a MySQL database, providing a simple yet efficient platform for managing
event data.

This system allows users to log in securely, register new accounts, and access event and venue management
features through a centralized dashboard. It ensures proper validation of data before storing it in the
database, reducing the risk of incorrect or duplicate entries.

Key features of the proposed system include:

●​ Secure login and registration using JDBC validation.​

●​ Add, update, delete, and view operations for events and venues.​

●​ Interactive and modern UI built with Java Swing.​

●​ Centralized storage in MySQL ensuring easy access and fast retrieval.​

●​ Reliable and scalable architecture that supports future expansions.​

The system aims to automate the entire event management process, improve accessibility, and ensure
accuracy and integrity of stored data.

2.3​Methodology

The Event Ticket Management System follows a three-tier architecture model consisting of:

1.​ Presentation Layer (Front End): Developed using Java Swing for GUI design, providing
interactive forms for user registration, login, and event management.​

2.​ Application Layer (Logic): Contains the business logic written in Java, including form validation,
database communication, and event-handling mechanisms.​

3.​ Database Layer (Back End): MySQL database stores user credentials, event details, and venue
information securely.​
The application communicates with the database using JDBC (Java Database Connectivity). Prepared
statements are used for secure and efficient SQL query execution, preventing SQL injection attacks and
ensuring data security.
 Chapter 3

IMPLEMENTATION DETAILS

3.1​System Requirement Specification

Software Specifications:

1.​ The Event Ticket Management System was developed using the Java programming language,
known for its platform independence, object-oriented features, and robustness. The project uses
Java Development Kit (JDK 17) as the primary development environment, which provides the
necessary compiler, runtime libraries, and tools for building and executing Java applications.

2.​ The graphical user interface (GUI) of the system has been implemented using Java Swing, a
component of Java’s standard library that provides lightweight, responsive, and
platform-independent window-based applications. Swing was chosen because it allows for efficient
GUI development without requiring additional libraries, and it offers extensive support for user
interface customization.

3.​ For the backend, MySQL 8.0 is used as the database management system. MySQL is a reliable,
open-source, and scalable relational database that supports high-performance data storage and
retrieval. It is well-suited for small and medium-scale applications like this project, where
efficiency and security are key requirements.

4.​ The connection between the front-end (Java Swing) and back-end (MySQL) is handled using
JDBC (Java Database Connectivity). JDBC is a powerful API that allows Java applications to
interact with relational databases by executing SQL commands directly from Java code. Using
PreparedStatement objects, the system ensures secure query execution and prevents SQL
injection vulnerabilities.

5.​ The application was developed and tested using IntelliJ IDEA, a modern integrated development
environment (IDE) widely used for Java-based projects. IntelliJ offers intelligent code completion,
built-in debugging tools, and efficient project structure management, which made the development
process smooth and organized.

6.​ The system was developed and tested on a Windows 10 operating system, ensuring compatibility
with the latest hardware and software standards. The application can, however, be easily deployed
on other operating systems like macOS and Linux, since Java is platform-independent.
7.​ In summary, the combination of Java Swing, MySQL, JDBC, and IntelliJ IDEA forms a
reliable, efficient, and easy-to-maintain software environment for building and executing the Event
Ticket Management System.

Hardware Specifications (based on development and testing environment):

1.​ The hardware requirements for the Event Ticket Management System are minimal, as the project
is designed to run as a lightweight desktop application. The system can operate efficiently on a
standard personal computer or laptop used by students and professionals for development and
testing purposes.

2.​ The minimum hardware configuration required to run this system includes an Intel Core i3 or
equivalent AMD Ryzen 3 processor, which provides sufficient computational power to handle
GUI operations and database connectivity. A minimum of 4 GB of RAM is required to ensure
smooth execution of the application, especially when multiple database queries or windows are
opened simultaneously. However, 8 GB of RAM is recommended for optimal performance during
development and testing.

3.​ The storage requirement for the system is relatively low. Approximately 500 MB of free disk
space is sufficient for installing the JDK, MySQL server, and the project files. Additional storage
may be required depending on the volume of event and venue data stored in the database over
time.

4.​ The application can be run on any standard display monitor with a resolution of 1024×768 pixels
or higher, ensuring that all GUI elements such as buttons, tables, and forms are properly visible
and accessible.

5.​ No special hardware devices are required to run the system, as it relies solely on standard
computing components like a keyboard and mouse for user input.

6.​ Thus, the hardware requirements for the Event Ticket Management System are simple and
cost-effective, making it easily deployable in any educational or organizational environment
without the need for advanced computing infrastructure.
 3.2​Platform and IDE

The Event Ticket Management System has been developed on a Windows platform using the Java
programming language and MySQL database. The selection of this platform was made due to its wide
availability, stability, and compatibility with Java-based applications. Windows provides a robust
environment for both development and testing, making it suitable for creating standalone desktop
applications.

For the development environment, IntelliJ IDEA was chosen as the Integrated Development
Environment (IDE). IntelliJ offers an advanced set of tools that simplify coding, debugging, and testing
processes. It provides real-time syntax highlighting, intelligent code completion, and efficient error
tracking, which helped in reducing development time and improving code quality. The IDE also supports
easy project structuring and dependency management, which is particularly useful for multi-class
applications like this system, where several modules interact with each other through database connections.

The Java Development Kit (JDK 17) was installed to provide the necessary runtime environment and
compiler support. JDK ensures that Java programs can be compiled and executed seamlessly within the
IDE. The MySQL Workbench was used for designing and testing database tables, executing SQL queries,
and validating the data flow between the front end and back end.

In addition to IntelliJ IDEA, the MySQL Connector/J driver was integrated into the project to enable
database connectivity through JDBC (Java Database Connectivity). This connector allows the Java
application to interact with the MySQL database securely and efficiently, supporting both read and write
operations.

Overall, the chosen platform and development tools created an ideal environment for building a
user-friendly, efficient, and reliable desktop-based management system. The combination of Java’s
platform independence, IntelliJ’s productivity features, and MySQL’s robust data handling capabilities
made the development process smooth and well-organized

3.3​Application Development and Implementation

The development and implementation of the Event Ticket Management System involved several stages,
starting from system design to coding, integration, and testing. The project was implemented following a
modular approach, where each functionality was developed as a separate unit before being combined into
the complete system.

The front end of the system was designed using Java Swing, which provides a rich set of graphical
components such as buttons, text fields, labels, and tables. The use of Swing allowed the creation of an
interactive, responsive, and visually appealing user interface. Every form — including the Login Page,
Registration Page, Dashboard, and Management Pages — was designed with clear layouts and intuitive
navigation to enhance the user experience.

The back-end development was carried out using MySQL, which stores and manages all event-related
information in an organized and structured manner. The system uses three main tables — users,
events, and venues — to handle data operations. Each table was designed with proper data types and
constraints to ensure referential integrity and accuracy. SQL queries were written to perform all CRUD
(Create, Read, Update, Delete) operations efficiently.

To connect the front end and back end, JDBC was used as the middleware. The JDBC API enables
seamless communication between the Java application and MySQL database. Prepared statements were
implemented in the code to prevent SQL injection and ensure data security. Database connection handling
was centralized in a dedicated class named DBConnection.java, which ensures consistent and
reusable connectivity throughout the application.

The implementation began with the Login and Registration modules, where users can securely register
and log in. After successful authentication, the Dashboard interface provides access to other modules such
as Manage Events and Manage Venues. These modules allow users to add new records, view existing
data in tabular form, and update or delete records as required.

All modules were tested individually to verify functionality before being integrated into the complete
system. Integration testing ensured smooth data flow between modules, while validation testing confirmed
that user inputs and database transactions behaved as expected. Exception handling mechanisms were
implemented to manage errors gracefully and improve reliability.

The final system operates smoothly, connecting the user interface and database seamlessly. The modular
design makes it easy to add future enhancements like ticket booking, payment gateways, and report
generation. In essence, the application development and implementation phase successfully converted
the system design into a fully functional, user-oriented software application.

.
 Chapter 4

SYSTEM

DESIGN

The system architecture of the Event Ticket Management System follows a three-tier architecture
model, which divides the entire application into three logical layers — the Presentation Layer, the
Application Layer, and the Database Layer. This architectural design improves scalability, modularity,
and maintainability, allowing each layer to function independently while communicating with the others in
a structured way

Figure 4.1 : System Architecture

 1.​Presentation Layer (View)

The Presentation Layer forms the topmost level of the system. It consists of the Graphical User
Interface (GUI) designed using Java Swing.​
It is the layer that interacts directly with the users, allowing them to perform various operations such as
login, registration, event creation, and venue management.​
All inputs are taken through forms, buttons, and text fields, while the output — such as success messages,
data tables, or error alerts — is displayed back on the interface.​
The design ensures a smooth and intuitive user experience, with simple navigation and responsive
interaction between different screens.

The main components in this layer include:

●​ Login Page: Validates user credentials.​

●​ Register Page: Stores new user information in the database.​

●​ Dashboard: Serves as the main control panel.​

●​ Manage Events: Allows adding, editing, and deleting event details.​

●​ Manage Venues: Handles venue-related operations.​

This layer communicates with the Application Layer to pass user requests and display results from the
database.

2.​Application Logic Layer (Controller)

The Application Layer acts as the middle layer between the user interface and the database.​
It contains the business logic of the application — the core functionality that processes user inputs,
performs necessary computations, and interacts with the database through SQL queries.

This layer is implemented in Java and uses JDBC (Java Database Connectivity) to handle database
operations. The DBConnection.java class establishes and maintains a stable connection to the
 MySQL server.​
Prepared statements are used to execute SQL commands securely, preventing SQL injection and ensuring
reliable data transactions.

The Application Layer includes:

●​ Input validation and data verification.​

●​ Execution of CRUD operations (Create, Read, Update, Delete).​

●​ Data exchange between GUI and database.​

●​ Error handling and feedback messages.​

This layer ensures that only valid data is passed to the database and that the results are returned to the user
in a readable format

3.​Data Storage Layer (Model)

The Database Layer is the foundation of the system architecture. It is responsible for storing, retrieving,
and managing all the data required by the system.​
The database is designed in MySQL and consists of three main tables — users, events, and venues.
Each table is structured with primary keys and appropriate data types to ensure integrity and avoid
redundancy.

●​ The users table stores login and registration details.​

●​ The events table maintains event information such as name, date, location, and description.​

●​ The venues table holds venue-specific details like venue name, city, and capacity.​

All data operations are performed through the Application Layer using SQL queries. The database ensures
data persistence, consistency, and security, forming the backbone of the system
 Chapter 5

Screen Shots

Figure 5.1 :login / register page

 Figure 5.2 : Main Dashboard

Figure 5.3 : Manage Events Page

 Figure 5.4 : Add Event Page

Figure 5.5 : Manage Venues Page

 Figure 5.6 : Log out Confirmation

Figure 5.8 : MySQL Database - users Table Data

 Chapter 6

Conclusion

The Event Ticket Management System was successfully developed and implemented to simplify and
automate the process of managing events and venues. The system provides a unified and efficient platform
where users can register, log in, and perform various management operations such as adding, updating, or
deleting event and venue details.

The project demonstrates the effective integration of Java Swing as a front-end interface and MySQL as
the backend database. By implementing JDBC (Java Database Connectivity), the system ensures smooth
communication between the user interface and the database, enabling real-time updates and data retrieval.

Through this system, the drawbacks of manual event management — such as data inconsistency,
redundancy, and time consumption — have been overcome. The modular structure of the program,
consisting of distinct functionalities for login, registration, event handling, and venue management, makes
it easier to maintain and expand in the future.

The system was tested successfully with multiple data entries, validating its performance, security, and
reliability. The user interface is designed to be interactive and intuitive, ensuring that users with minimal
technical knowledge can operate it efficiently.

Overall, the Event Ticket Management System achieves its primary objective of providing a practical,
reliable, and easy-to-use software solution for event and venue management. It also demonstrates a strong
foundation for future enhancements and real-world deployment.
 Future Scope :

While the current version of the Event Ticket Management System efficiently handles user registration,
event creation, and venue management, it can be expanded with several additional features to make it more
dynamic and applicable in real-world scenarios.

The following improvements can be considered as part of the system’s future development scope:

1.​ Ticket Booking Module:​

Integration of a ticket booking feature where users can reserve or purchase tickets for different
events directly through the system.​

2.​ Payment Gateway Integration:​

Implementation of online payment options using secure APIs such as Razorpay or PayPal for
smooth financial transactions.​

3.​ Role-Based Access Control:​

Introducing user roles such as “Admin” and “Customer” to provide controlled access to different
features based on privileges.​

4.​ Email and Notification System:​

Automated email confirmations or notifications for successful bookings and upcoming events.​

5.​ Report Generation and Analytics:​

Adding functionalities for generating reports on events, venues, and bookings, and using data
analytics to identify trends and performance metrics.​

6.​ Cloud Integration:​

Hosting the database and application on a cloud platform like AWS or Google Cloud for better
scalability, remote access, and data backup.​

7.​ Web or Mobile Version:​

Expanding the desktop application into a web or mobile-based system to improve accessibility and
convenience for users.​
 The modular architecture of the current system makes it adaptable for such upgrades without major
restructuring. These future improvements would transform the project from a simple event
management tool into a comprehensive event planning and ticketing platform.

7. References

During the development of the Event Ticket Management System, several online and offline
resources were referred to in order to gain a clear understanding of the technologies used, including
Java Swing, MySQL, and JDBC connectivity.
These references provided valuable insights into the concepts of database handling, GUI design, and
software development methodologies.
Textbooks, technical documentation, and tutorial websites were especially helpful in understanding
how to integrate front-end and back-end technologies effectively

The following references were used throughout the course of the project:
Oracle Corporation. Java Platform, Standard Edition Documentation.​
This official documentation provided a detailed understanding of the Java programming language,
libraries, and APIs used for building GUI-based applications.​
Available at: https://docs.oracle.com/javase/​

MySQL Documentation. MySQL 8.0 Reference Manual.​

This was used to study database structure creation, SQL commands, and database connectivity
through JDBC.​
Available at: https://dev.mysql.com/doc/​

Herbert Schildt. Java: The Complete Reference, 12th Edition. McGraw-Hill Education, 2022.​
This textbook served as a comprehensive guide for mastering Java syntax, OOP principles, and
GUI programming.​

E. Balagurusamy. Programming with Java: A Primer, 6th Edition. McGraw-Hill Education, 2019.​
This book provided a strong theoretical foundation and practical examples for understanding Java
programming concepts.​

Java Swing Tutorial – Oracle Java Tutorials.​

This resource was instrumental in learning how to create responsive and interactive GUIs for the
application using Swing components.​
Available at: https://docs.oracle.com/javase/tutorial/uiswing/​

TutorialsPoint. JDBC - Java Database Connectivity.​

This online tutorial helped in understanding how to connect Java applications to MySQL databases
and perform CRUD operations efficiently.​
Available at: https://www.tutorialspoint.com/jdbc/​

JetBrains Documentation. IntelliJ IDEA User Guide.​

This documentation guided the setup and configuration of the IntelliJ IDEA IDE used for
developing and testing the Java project.​
Available at: https://www.jetbrains.com/idea/documentation/​

GeeksforGeeks. JDBC and Database Connectivity in Java.​

Helped in clarifying key concepts such as prepared statements, exception handling, and connection
pooling.​
Available at: https://www.geeksforgeeks.org/jdbc-in-java/​

YouTube Tutorials – Bro Code / Telusko Java Series.​

Offered practical demonstrations of Swing UI design and database integration using JDBC.​

Stack Overflow.​
Provided quick solutions to specific implementation errors encountered during development and
testing phases.​
Available at: https://stackoverflow.com