1.
Introduction
Educational institutions handle a large volume of student-related data
daily. These details include personal information, academic records,
contact information, department details, and fee records. Traditionally,
these operations are performed using manual registers, physical files, or
spreadsheets. Although commonly used, these methods suffer from
several drawbacks such as data redundancy, loss of data, difficulty in
searching specific information, and increased possibilities of human
errors.
To address these issues, computerized management systems have become
essential in educational environments. A Student Record Management
System (SRMS) serves as a digital platform that facilitates smooth data
entry, retrieval, modification, and deletion. Such a system not only
improves efficiency but also ensures accuracy, reduces time consumption,
and enhances data security.
1.1 Problem Statement
The lack of centralized and structured data handling creates
administrative delays and errors. Without automation:
Searching for student records becomes time-consuming
Fee tracking becomes inconsistent
Manual data entry leads to high chances of errors
Maintaining historical data becomes difficult
These issues highlight the need for a computerized system that minimizes
manual workload and supports fast, error-free operations.
1.2 Purpose of the Project
The purpose of this project is to design and implement a user-friendly
desktop application that allows easy management of student and fee
information. It focuses on:
Eliminating manual data errors
Ensuring structured data storage
Providing quick access to student information
Maintaining fee records properly
1.3 Scope of the Project
The project enables:
Adding, viewing, updating, and deleting student details
Maintaining department-wise records
Handling fee payment details, balances, and payment dates
Providing clear and interactive graphical user interface
Supporting accurate database operations
The system is built for administrators and academic staff who manage
student databases.
2. Requirements Specification
2.1 Functional Requirements
The system must perform the following operations:
2.1.1 Student Management
Add new student record
View all students
Search specific students
Delete existing records
Reset fields for new entries
2.1.2 Fee Management
Add fee payment details
Calculate remaining balance
View all payments made by students
Display payment history in a table view
2.1.3 Data Validation
Mandatory fields must be filled correctly
Contact number must contain digits only
Date format must be valid
Prevent duplicate entry
2.1.4 UI Functional Requirements
GUI must show all records in a TreeView
Dropdown selection for names in fee window
Confirmation and error messages must appear as pop-ups
2.2 Non-Functional Requirements
2.2.1 Performance
Data retrieval must be fast (within milliseconds)
System must run smoothly even with large data
2.2.2 Reliability
Database should not crash
No data loss should occur after saving
2.2.3 Usability
Interface should be easy for non-technical staff
Clear buttons and layout
2.2.4 Security
Only admin users can access the system
Data stored in SQLite must not be editable manually
2.2.5 Portability
Application should run on any PC with Python installed
3. System Design
3.1 System Architecture Diagram
3.2 UML Diagrams
3.2.1 Use Case Diagram
Actor: Admin
Use Cases:
Add Student
Delete Student
View Records
Update Fees
Calculate Balance
Reset Form
3.2.2 Class Diagram:-
4. Implementation
4.1 Technology Stack
Frontend: Tkinter
Backend: SQLite3
Programming Language: Python
IDE Used: PyCharm
OS: Windows 10
4.2 Database Structure
4.2.1 MANAGEMENT Table
Field Name Type Description
STUDENT_ID Integer Primary key
NAME Text Student name
PHONE_NO Text Contact number
GENDER Text Male/Female
DOB Text Date of birth
DEPARTMENT Text Course/Department
TOTALFEES Text Total fee amount
4.2.2 FEES Table
Field Name Type Description
BILL_NO Integer Primary key
STUDENT_ID Integer Linked to MANAGEMENT table
BILL_DATE Text Payment date
AMOUNT Text Fee paid
4.3 Key Interface Screens (Descriptions)
Student Window
Input boxes for name, phone, gender, DOB, department, fees
Buttons: Add, Delete, View, Reset, Fee Details
TreeView displaying all student records
Fee Window
Dropdown for student names
Shows department, total fees, balance
Inputs for amount and date
Buttons for add/delete/view/reset
Fee history displayed in TreeView
4.4 Major Code Highlights
1. Database Table Creation
This code ensures the required tables (MANAGEMENT and FEES)
are created automatically if they do not exist.
connector.execute("""
CREATE TABLE IF NOT EXISTS MANAGEMENT (
STUDENT_ID INTEGER PRIMARY KEY
AUTOINCREMENT,
NAME TEXT,
PHONE_NO TEXT,
GENDER TEXT,
DOB TEXT,
DEPARTMENT TEXT,
TOTALFEES TEXT
)
""")
connector.execute("""
CREATE TABLE IF NOT EXISTS FEES (
BILL_NO INTEGER PRIMARY KEY AUTOINCREMENT,
STUDENT_ID INTEGER,
BILL_DATE TEXT,
AMOUNT TEXT
)
""")
2. Adding a New Student Record
This function validates input fields and inserts a new record into the
database.
def add_record():
name = name_strvar.get()
contact = contact_strvar.get()
gender = gender_strvar.get()
dobv = dob.get_date()
department = department_strvar.get()
totalfees = total.get()
if not name or not contact or not gender or not department:
mb.showerror("Error", "All fields must be filled!")
return
connector.execute("""
INSERT INTO MANAGEMENT (NAME, PHONE_NO,
GENDER, DOB, DEPARTMENT, TOTALFEES)
VALUES (?, ?, ?, ?, ?, ?)
""", (name, contact, gender, dobv, department, totalfees))
connector.commit()
mb.showinfo("Success", f"Record of {name} added
successfully!")
display_records()
3. Deleting a Student Record
This function deletes the selected student using their unique
STUDENT_ID.
def remove_record():
selected_item = tree.focus()
values = tree.item(selected_item)["values"]
if not values:
mb.showerror("Error", "Please select a record to delete!")
return
connector.execute("DELETE FROM MANAGEMENT WHERE
STUDENT_ID = ?", (values[0],))
connector.commit()
mb.showinfo("Deleted", "Record deleted successfully.")
display_records()
4. Adding a Fee Payment
This function inserts a fee payment for the selected student and
updates the fee list.
def add_fee_record():
student_id = rows[namebox.current()][0]
pay_date = db.get_date()
amt = amount.get()
connector.execute("""
INSERT INTO FEES (STUDENT_ID, BILL_DATE,
AMOUNT)
VALUES (?, ?, ?)
""", (student_id, pay_date, amt))
connector.commit()
mb.showinfo("Success", "Fee payment added successfully!")
display_fee_records()
5. Calculating Remaining Balance
The system calculates the outstanding balance for each student by
summing all payments.
curr = connector.execute("""
SELECT SUM(amount) FROM FEES
WHERE student_id = ?
""", (row[0],))
paid_amount = curr.fetchone()[0]
balance = int(row[6]) - (paid_amount if paid_amount else 0)
balance_strvar.set(balance)
6. Displaying Records in the TreeView
The following code loads all student records from the database into
a graphical table.
def display_records():
tree.delete(*tree.get_children())
data = connector.execute("SELECT * FROM
MANAGEMENT").fetchall()
for record in data:
tree.insert("", "end", values=record)
The implementation of the Student Record Management System consists
of several important code components that handle the core functionality
of the application. Some of the major code highlights are:
1. Database Table Creation
The system automatically creates the required SQLite tables
(MANAGEMENT and FEES) if they do not already exist. This ensures
the database is always ready before performing operations.
2. Add Student Record Function
This function collects all student details from the GUI, validates the
inputs, and inserts a new record into the MANAGEMENT table. It also
displays a confirmation message and refreshes the data table.
3. Delete Student Record Function
The delete function removes the selected record from the database using
the student’s unique ID. After deletion, the GUI is updated to reflect the
change.
4. Load Student List for Fee Module
A function retrieves all student names from the database and populates
the dropdown list in the fee payment section. This supports quick
selection and reduces errors.
5. Add Fee Payment Function
This function inserts fee payment data into the FEES table. It also
recalculates the student's balance by summing all payments made so far.
6. View Record Functionality
Clicking a record in the table loads all its details back into the input
fields. This helps users review or verify information easily.
7. Input Validation
The system uses conditions to ensure required data is entered correctly
(e.g., phone number must be digits, no field left blank). Error messages
guide users when incorrect inputs are detected.
5. Testing
5.1 Testing Types
Black Box Testing: Focus on input and output
White Box Testing: Function-level testing
5.2 Sample Test Cases Table
TC Test Scenario Input Expected Actual Status
No Output Result
1 Add student All valid Success Success Pass
fields message
2 Add student Blank phone Error popup Error Pass
missing phone shown
3 Delete student Select record Record Deleted Pass
deleted
4 Fee payment Valid amount Payment Success Pass
added
5 Balance check After multiple Correct Accurate Pass
payments balance
5.3 Bug Fixes
Resolved issue of incorrect balance calculation
Fixed dropdown not loading new students
Updated TreeView auto-refresh
6. Conclusion and Future Work
Conclusion
The Student Record Management System effectively automates academic
administrative activities by simplifying student and fee record handling. It
replaces manual registers with a structured, accurate, and efficient
system. Easy-to-use interfaces reduce the workload of staff and minimize
human errors.
Future Enhancements
Add login authentication system
Export data to PDF or Excel
Add attendance tracking
Introduce face recognition module
Convert into a web-based system (Flask/Django)
Add SMS/Email notifications
7.References
Python in a Nutshell
The Python Language Reference Manual. Python Software
Foundation.
SQLite Consortium. https://sqlite.org/docs.html
TkDocs. https://tkdocs.com
8. ACKNOWLEDGMENT
I would like to express my sincere gratitude to my project guide and the
faculty for their support, guidance, and encouragement throughout the
completion of this mini-project. I am also thankful to my college for
providing the necessary resources and a motivating environment to carry
out this work successfully.
