VISVESWARAYA TECHNOLOGICAL UNIVERSITY

Jnana Sangama, Belagavi-590018

A Mini-Project Report
on
"Student Management System Using Java”

Submitted on partial fulfillment of academic requirement of 4th semester JAVA laboratory

BACHELOR OF ENGINEERING
In
Department of Computer Science and Engineering

Submitted By

Srushti Anilkumar-1BY24CS287

Under The Guidance of

Mrs. Aruna N
Mrs. Shilpa M
Mrs. Manjula S D
Mrs. Renita B M
Assistant Professor
Computer Science

Department of Computer Science and Engineering

BMS INSTITUTE OF TECHNOLOGY AND MANAGEMENT
(Autonomous Institute Affiliated to VTU)
Avalahalli, Yelahanka, Bengaluru –
560119.
2025-2026
 VISVESWARAYA TECHNOLOGICAL UNIVERSITY
Jnana Sangama, Belagavi-590018
BMS INSTITUTE OF TECHNOLOGY AND MANAGEMENT
(Autonomous Institute Affiliated to VTU)
Avalahalli, Yelahanka, Bengaluru – 560064.
Department of Computer Science and Engineering

CERTIFICATE

This is to certify that the MC Mini-Project entitled “Student Management System Using
Java Swing and SQLite” has been carried out by Srushti Anilkumar-1BY24CS287 a
bonafide student of BMS Institute of Technology and Management, Autonomous Institute
Affiliated to VTU, in partial fulfillment for IV semester B.E project work in the
Department of Computer Science and Engineering in Visvesvaraya Technological
University, Belagavi , during the academic year 2025-2026 (Even Semester). It is
certified that all corrections/suggestions indicated for assessment have been incorporated
in the report deposited in department library. The project report has been approved as it
satisfies the academic requirements in respect of Mini-Project work prescribedfor the said
degree.

Signature of the Guide Signature of the Head (Division

1) Mrs. Aruna N Dr. Mahesh G
Assisstant Professor Professor & Head (Division 1)
CSE Dept., BMSIT&M CSE Dept., BMSIT&M
 DECLARATION
We hereby declare that the mini project titled “Student Management System Using Java Swing and
SQLite” submitted as part of the academic requirements is an original work carried out by our team
under the guidance and supervision of our faculty guide. We confirm that the project work presented
in this report has been developed using our own knowledge, implementation techniques, and
programming skills. The information, Java Swing graphical interface, SQLite database
implementation, JDBC connectivity, SQL queries, and application modules included in this project
are genuine to the best of our knowledge and belief. We further declare that this report has not been
submitted either fully or partially to any other institution or university for the award of any degree,
diploma, or certificate. This project has helped us gain practical knowledge of Java programming,
database management systems, GUI development, JDBC connectivity, and desktop application
development.
 ACKNOWLEDGEMENT

We express our sincere gratitude to our institution for providing us with the opportunity and facilities
to successfully complete this mini project titled “Student Management System Using Java Swing and
SQLite”. We would like to convey our heartfelt thanks to our faculty guide for the valuable guidance,
encouragement, and continuous support throughout the development of this project. Their suggestions
and motivation helped us complete the project successfully. We also extend our gratitude to the Head
of the Department and all faculty members for their support and encouragement during the course of
this project work. Finally, we express our sincere thanks to our friends and family members for their
constant encouragement and moral support throughout the completion of this project.
 ABSTRACT
The Student Management System is a desktop-based mini project developed using Java Swing as the
frontend and SQLite as the backend database. JDBC connectivity is used to establish communication
between the Java application and the database system. The application is designed to manage student
records efficiently through a graphical user interface. The system allows users to add student
information, view stored records, delete records, and manage multiple student entries in an organized
manner. SQLite provides lightweight and efficient database storage while Java Swing provides an
interactive and user-friendly interface for application interaction. The project demonstrates practical
implementation of Java GUI development, database connectivity, SQL operations, and CRUD
functionalities. The system is simple, reliable, lightweight, and suitable for educational institutions
and beginner-level database management applications.
Chapter No. Chapter Title Page No.
Abstract ii
Acknowledgement iii
Declaration iv
List of Figures v
List of Tables vi
Chapter 1 Introduction 1
1.1 Background 2
1.2 Problem Definition 3
1.3 Objectives 4
1.4 Scope of the Project 5
Chapter 2 System Requirements and Specifications 6
2.1 Hardware Requirements 7
2.2 Software Requirements 8
2.3 Functional Requirements 9
2.4 Non-Functional Requirements 10
Chapter 3 System Design 11
3.1 System Architecture 12
3.2 Database Design 13
3.3 Flowchart 14
3.4 Working Principle 15
Chapter 4 Implementation 16
4.1 Java Program Implementation 17
4.2 SQLite Database Connectivity 18
4.3 Program Features 19
Chapter 5 Testing 20
5.1 Testing Strategy 21
5.2 Unit Testing 22
5.3 Integration Testing 23
5.4 System Testing 24
Chapter 6 Results and Discussion 25
6.1 Results 26
 CHAPTER 1: INTRODUCTION

1.1 Background

Student information management plays an important role in educational institutions. Traditional

manual methods of maintaining records are time-consuming, inefficient, and prone to human errors.
Managing large numbers of student records manually also creates difficulties in data retrieval,
modification, and storage. With increasing digitalization, educational institutions require automated
systems capable of storing and managing student information efficiently. Java-based desktop
applications provide a reliable solution for creating simple management systems with graphical user
interfaces and database integration. The Student Management System is developed using Java Swing
and SQLite database to provide a lightweight and user-friendly solution for maintaining student
information digitally. JDBC connectivity is used to establish communication between the frontend
and backend database. The application performs important operations such as adding student records,
viewing records, deleting records, and handling multiple entries effectively.

1.2 Problem Definition

Educational institutions often face difficulties in maintaining student records manually. Traditional
record management methods consume more time, require physical storage space, and increase the
possibility of data duplication and human errors. The absence of a simple computerized management
system creates inefficiency in handling student information. Therefore, there is a need for a
lightweight, fast, and user-friendly application capable of storing, retrieving, and managing student
records efficiently

1.3 Objectives

The primary objectives of the Student Management System project are:

• To develop a desktop-based application using Java Swing.
• To establish database connectivity using JDBC.
• To store and manage student information using SQLite database.
• To perform CRUD operations effectively.
• To create a user-friendly graphical interface.
• To understand practical implementation of Java database integration.
1.4 Scope of the Project

The scope of the project includes development of a desktop application capable of storing and
managing student information. The application allows users to enter student details such as ID, name,
department, and phone number.

The project includes:

• Java Swing frontend development
• SQLite database creation
• JDBC connectivity
• CRUD operation implementation
• Record display using JTable

The project is suitable for educational institutions and beginner-level database management
applications.
CHAPTER 2: SYSTEM REQUIREMENTS AND SPECIFICATIONS

2.1 Hardware Requirements

Component Specifications Quantity Purpose

Running the
Intel i3 / AMD Student
Processor 1
equivalent or higher Management
System
Smooth execution
RAM Minimum 4 GB 1
of Java application
Storage for project
500 MB free disk
Storage 1 files and SQLite
space
database
User
1366 × 768
Display Monitor 1 interface
resolution or higher
display
Data entry and system
Keyboard Standard keyboard 1
operation
Optical mouse / Navigation and
Mouse 1
touchpad interaction
Standard PC/Laptop
Power Supply 1 System operation
power

Component Specifications Quantity Purpose

Running the
Intel i3 / AMD Student
Processor 1
equivalent or higher Management
System

2.2 Software Requirements

Software / Tool Purpose Version Platform

Code development,
IntelliJ IDEA / VS
compilation, and Latest Windows
Code
debugging
Local database
SQLite Database storage and SQLite 3 Cross-platform
management

Source code editing

Text Editor Any modern editor Cross-platform
and development
2.3 Functional Requirements

Functional requirements define the specific operations and capabilities that the system must perform
to meet project objectives:
• Add student records into the database.
• Display all student records dynamically.
• Delete records using student ID.
• Clear input fields for new entries.
• Establish reliable database connectivity.

2.4 Non-Functional Requirements

Non-functional requirements specify quality attributes and performance characteristics of the system:
• Simple and user-friendly interface.
• Lightweight database implementation.
• Fast execution and response time.
• Reliable storage and retrieval of records.
• Easy maintainability and scalability.
 CHAPTER 3: SYSTEM DESIGN

3.1 System Architecture

The Student Management System follows a simple architecture where the frontend communicates
with the database using JDBC connectivity. The frontend collects user input and sends SQL queries
to the SQLite database using JDBC. The database stores and retrieves student information whenever
required.
3.2 Database Design
Database Name: [Link]

Table Name: students

Column Name Data Type Description

id INTEGER Primary Key

name TEXT Student Name

department TEXT Department

phone TEXT Phone Number

3.3 SQL Queries Used

Create Table Query:

CREATE TABLE IF NOT EXISTS students(

id INTEGER PRIMARY KEY,
name TEXT,
department TEXT,
phone TEXT
);

Insert Query:

INSERT INTO students VALUES(?,?,?,?);

Select Query:

SELECT * FROM students;

Delete Query:

DELETE FROM students WHERE id=?;

3.4 Flowchart

The application starts by initializing the graphical user interface and database connection. User input
is accepted through text fields. Depending on button actions, the application performs add, view,
delete, or clear operations using SQL queries
 CHAPTER 4: IMPLEMENTATION

4.1 Frontend Design

The graphical user interface is developed using Java Swing components such as JFrame, JLabel,
JTextField, JButton, JTable, JScrollPane, and JPanel. The GUI allows users to enter student
information and perform database operations through interactive [Link] JFrame acts as the main
application window. Labels are used to display field names such as Student ID, Name, Department,
and Phone Number. JTextFields allow users to enter student information. Buttons are provided for
performing operations such as Add Student, View Students, Delete Student, and Clear Fields. JTable
is used to display student records dynamically in tabular format. The interface is designed in a
simple, organized, and user-friendly manner so that users can interact with the application easily
without technical difficulties. The frontend design ensures proper alignment of components, easy
navigation, and better user experience

4.2 Database Connectivity

JDBC Database connectivity is established using JDBC (Java Database Connectivity). JDBC acts as
an interface between the Java application and the SQLite database.
The SQLite JDBC Driver is added to the project libraries to enable communication between Java and
SQLite. The Driver Manager class is used to establish the database connection.
The connection URL used in the project is:
jdbc:sqlite:[Link]
The Connection object establishes the communication link with the SQLite database. SQL queries
are executed using Prepared Statement and Statement objects. Prepared Statement is mainly used
because it improves efficiency and prevents SQL injection vulnerabilities. The Result Set object is
used to retrieve records from the database
4.3 Functional Modules

The Student Management System consists of multiple functional modules that perform different
operations within the application.
Add Student Module
This module allows users to enter student details such as student ID, name, department, and phone
number. After entering the details, the Add button inserts the information into the SQLite database
using SQL INSERT queries.
The module validates user input and ensures that records are stored correctly in the database.
View Students Module
This module retrieves all stored student records from the SQLite database using SQL SELECT
queries. The retrieved records are displayed dynamically using JTable.
The JTable component allows users to view multiple student records in an organized tabular format.
Delete Student Module
This module deletes student records from the database based on the entered student ID. SQL
DELETE queries are used to remove records from the students table.
The module helps maintain accurate and updated records within the system.
Clear Fields Module
This module clears all input text fields present in the GUI. It helps users enter new student
information without manually deleting previously entered values.
 CHAPTER 5: TESTING

5.1 Testing Strategy

Testing is an important phase in software development because it ensures that the application
performs correctly and meets all functional requirements. The Student Management System was
tested using different testing methods to verify the correctness, reliability, and efficiency of the
system.
The testing process included:
 Unit Testing
 Integration Testing
 System Testing
Each module of the application was tested individually and then combined together to ensure smooth
communication between the frontend and backend database.
The testing process mainly focused on:
 Correct execution of CRUD operations
 Proper GUI functionality
 Successful database connectivity
 Error-free execution
 Accurate data storage and retrieval
The application was tested multiple times using different student records to ensure stability and
consistency.

5.2 Unit Testing

Unit testing focuses on testing individual modules separately to ensure that each component performs
its intended functionality correctly. In the Student Management System, different modules such as
Add Student, View Students, Delete Student, and Clear Fields were tested independently. The Add
Student module was tested by entering different student records into the text fields and inserting them
into the SQLite database. The module successfully stored records without generating errors. The
View Students module was tested to ensure that all stored records were displayed correctly in JTable
format. Multiple records were inserted into the database and verified successfully. The Delete
Student module was tested by entering valid student IDs and deleting corresponding records from the
database. The module successfully removed records and updated the displayed table dynamically.
The Clear Fields module was tested to ensure that all text fields became empty after clicking the
Clear button.
5.3Integration Testing

Integration testing verifies communication and interaction between different modules of the
application. In the Student Management System, integration testing mainly focused on frontend-to-
database interaction using JDBC connectivity.
The Java Swing frontend was tested together with the SQLite database to ensure successful
communication between the user interface and backend system. Operations such as adding, viewing,
and deleting records were performed repeatedly to confirm proper execution of SQL queries and
smooth transfer of data between the frontend and backend.
The JDBC connectivity layer was also tested to ensure successful database connection establishment
and query execution. SQL queries including INSERT, SELECT, and DELETE were executed
multiple times to verify proper synchronization between the graphical user interface and database.
The integration testing results confirmed that all modules communicated properly with each other
and that the complete application functioned smoothly without runtime issues.

5.4System Testing
System testing confirms that the integrated system meets all specified functional and non-functional
requirements. System testing is performed to verify the complete functionality of the application as a
whole. The Student Management System was tested under different conditions to ensure stable and
reliable performance.

Multiple student records were inserted into the database to test the application’s ability to handle
large numbers of entries. The system successfully displayed records dynamically in JTable format
and performed deletion operations without affecting other stored records.

The application was also tested for runtime stability and response time. The system executed all
operations quickly without noticeable delays. GUI components responded correctly to user
interactions and database operations executed successfully without crashes or errors.

The complete system testing process confirmed that the Student Management System satisfied all
functional requirements and performed efficiently under normal operating conditions.
5.5Security and Reliability Testing

The testing results showed that the Student Management System successfully performed all required
functionalities without major errors. Student records were inserted, displayed, and deleted
successfully from the SQLite database. JDBC connectivity remained stable throughout execution and
JTable displayed records dynamically without formatting issues.
The application demonstrated reliable performance, smooth execution, and proper synchronization
between the frontend and backend systems. The testing phase confirmed that the project met all
specified objectives and functioned correctly as a database-driven desktop application.
 CHAPTER 6: RESULTS AND DISCUSSION

6.1 Results

The Student Management System was successfully developed and implemented using Java Swing
and SQLite database. The application achieved all project objectives and demonstrated successful
integration between the graphical user interface and backend database management system.
The system successfully performed CRUD operations including adding student records, viewing
stored records, deleting records, and managing multiple entries efficiently. The SQLite database
stored and retrieved student information accurately without data loss or corruption. The graphical
user interface developed using Java Swing provided smooth interaction and easy usability. JTable
dynamically displayed student records in an organized tabular format. The application handled
multiple student records efficiently and maintained stable performance throughout execution. The
JDBC connectivity established reliable communication between the frontend and backend systems.
SQL queries executed successfully without runtime issues. Overall, the project demonstrated
successful implementation of database-driven desktop application development using Java
technologies.

6.2 Advantages

The Student Management System provides several advantages over traditional manual methods of
maintaining student records. The application offers a simple and user-friendly graphical interface that
allows users to manage records easily without technical complexity.

SQLite database implementation makes the system lightweight and efficient because it does not
require a separate database server. This reduces installation complexity and improves portability. The
application provides fast execution and quick response time during database operations.

The system efficiently stores and retrieves student information while reducing manual work and
improving record management. Multiple student records can be handled dynamically and displayed
in organized tabular format using JTable.

The modular structure of the project makes the application easy to maintain, modify, and enhance in
the future. The project also provides educational value by helping students understand practical
implementation of Java programming, JDBC connectivity, and database management systems.
6.3 Limitations and Future Enhancements

Although the Student Management System performs all intended functionalities successfully, certain
limitations still exist within the application. The project is mainly suitable for small-scale database
management applications and educational purposes. The system currently does not include
authentication or login security features. Search and filter functionalities are also not implemented in
the present version. The application supports only desktop environments and does not provide cloud-
based database storage. The project currently focuses on basic CRUD operations and does not include
advanced features such as report generation, online access, attendance management, or automated
backup systems. These limitations can be improved in future versions of the application. Several
improvements and additional features can be implemented in future versions of the Student
Management System. An Update Student module can be added to allow modification of existing
student records. Search and filter functionalities can also be implemented for easier data retrieval.
Authentication and login systems can be added to improve application security and prevent
unauthorized access. The graphical user interface can be enhanced further using advanced Java
libraries and modern design techniques. The application can also be integrated with cloud-based
databases or converted into a web-based management system for large-scale usage. Additional modules
such as attendance management, marks management, report generation, and automated backup systems
can also be included in future implementations.
 CHAPTER 7: CONCLUSION

The Student Management System successfully demonstrates the practical implementation of Java
Swing graphical user interface development and SQLite database integration using JDBC connectivity.
The application provides a simple, efficient, and lightweight solution for managing student information
digitally. The project successfully performs CRUD operations including adding, viewing, deleting, and
managing multiple student records dynamically. SQLite database ensures efficient data storage and
retrieval while Java Swing provides an interactive and user-friendly interface for application
interaction. The project helped in understanding important programming concepts such as Java GUI
development, database connectivity, SQL query execution, event handling, JTable implementation, and
JDBC integration. The modular design of the application makes it easy to maintain and extend in future
versions. The Student Management System fulfills all specified objectives and demonstrates practical
implementation of database-driven desktop application development. The project provides a strong
foundation for developing larger and more advanced management systems in the future.
 REFERENCES
[1] Oracle Java Documentation
[2] SQLite Official Documentation
[3] JDBC API Documentation
[4] Java Swing Tutorials
[5] IntelliJ IDEA Documentation
[6] Database Management System Concepts
[7] Java Programming by Herbert Schildt
[8] Introduction to Java Programming by Y. Daniel Liang
[9] SQLite JDBC Driver Documentation
[10] Java GUI Programming Concepts and Examples