Geetanjali Institute of Technical Studies, Dabok

Department of Computer Science and Engineering

Student Management System

Project Report submitted

in

DBMS LAB (4CS4-22)

in Department of Computer Science and Engineering

Lab Faculty: Submitted By:

Ms. Charu Kavadia, Shriya Ameta (23EGICS159)
Assistant Professor Vanshika Sharma (23EGICS184)
Yakshi Choubisa (23EGICS188)

6 May 2025

1
 TABLE OF CONTENTS

1. INTRODUCTION_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ __ _ _ _ _ _ _ _ _ __ _ _ _ _ _3

1.1 Problem Statement

1.2 Project Benefits

2. OBJECTIVES & SCOPE OF THE PROJECT_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ __5

2.1 Objective

2.2 Scope

3. SOFTWARE REQUIREMENT SPECIFICATION_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _6

3.1 Functional Requirement

3.2 Non-Functional Requirement

4. TECHNICAL IMPLEMENTATION & CODING_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ __8

5. PROJECT SCREENSHOTS_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _12

5.1 Interface of SMS

5.2 Adding Information

6. CONCLUSION & FUTURE WORK _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ __ __14

6.1 Conclusion

6.2 Future Work

2
 1. INTRODUCTION

A Student Management System (SMS) is a software application designed to manage student

data and academic records efficiently. It provides tools for adding, updating, and viewing
student information, including attendance, grades, and contact details.

1.1 Problem Statement

In many schools and colleges, student records are maintained manually, leading to errors, data
loss, and time-consuming operations. There is a need for an automated system that manages
student information in a centralized and efficient way.

1.2 Project Benefits

The Student Management System offers several significant benefits that improve the overall
efficiency of managing student data. It saves time by automating tasks such as student
registration, attendance tracking, and grade recording, which reduces the workload on teachers
and administrators. The system enhances data accuracy by minimizing manual entry errors,
ensuring that student records are reliable and up to date. With all information stored in a
centralized database, it allows for easy and quick access to student details when needed.
Additionally, it can generate performance and attendance reports instantly, which helps in
academic planning and monitoring. Digital record-keeping also eliminates the need for bulky
paper files, making data management more organized and secure.

• Easy storage and retrieval of student information

• Better data accuracy and consistency
• Reduces paperwork and administrative burden
• Quick generation of reports and student performance
• Improves communication between teachers, students, and parents

3
 2. OBJECTIVES & SCOPE OF THE PROJECT

2.1 Objectives
• To develop a secure, user-friendly application to manage student data.
• To allow admins to add, edit, delete, and search student records.
• To maintain academic records like attendance and marks.
• To generate reports for individual students.

2.2 Scope
This system is ideal for use in schools, colleges, or coaching institutions. It can be enhanced
further by integrating modules for fee tracking, exam scheduling, and notifications:
• Manages student personal and academic records efficiently.
• Allows administrators to add, update, delete, and search student details.
• Maintains attendance records and academic performance (marks/grades).
• Can be used by schools, colleges, coaching centers, and training institutes.
• Provides secure login and access control for different user roles.
• Can be expanded into a web or mobile-based application in the future.

4
 3. SOFTWARE REQUIREMENT SPECIFICATION
The Software Requirement Specification (SRS) defines all the technical and functional needs
of the Department and Course Management System. It describes what the system should do,
how it should perform, and the tools required to build and run the project. This ensures that
developers, users, and stakeholders have a clear understanding of the system.

3.1 Functional Requirements

These are the core functions the system must perform:
• The system must allow admin users to log in with a valid username and password.
• Only authorized users should be able to access and manage student records.
• The system must allow the admin to add new student details such as name, class,
contact info, etc.
• The system should allow editing or updating existing student records when needed.
• The system should allow entry of daily attendance and store it for each student.

3.2 Non-Functional Requirements

These define the performance and behavior of the system:
• The system should load student records within 2 seconds for up to 500 records.
• The interface must be simple and user-friendly for non-technical staff.
• Passwords must be encrypted.
• Only authorized users can access sensitive information.

3.3 Software Requirements

● Front-End (Optional): HTML, CSS for user interface (if using a web interface).
● Back-End: MySQL or any relational database system.
● Programming Language (Optional): Java, PHP, or Python if implementing
application logic.
● Database Tool: MySQL Workbench or phpMyAdmin.
● Operating System: Windows or Linux (any platform supporting the tools above).
● Text Editor/IDE: VS Code, Eclipse, NetBeans (based on chosen language).

3.4 Hardware Requirements

● Processor: Intel i3 or better
● RAM: Minimum 4GB

5
 4. TECHNICAL IMPLEMENTATION & CODING

The Student Management System was developed using a combination of database

management and programming tools. This section outlines how the system was built and
implemented, including the database design and code structure.

4.1 System Architecture

The SMS follows a basic client-server architecture:

• Client-side (optional UI): HTML/CSS if a web interface is used.

• Server-side logic: Handled using Python, Java, or PHP.
• Database: MySQL used to store student information and academic records.

Code:

import tkinter as tk
from tkinter import ttk, messagebox
import sqlite3

# === Database Setup ===

def connect_db():
conn = sqlite3.connect("students.db")
cur = conn.cursor()
cur.execute("""
CREATE TABLE IF NOT EXISTS students (
roll INTEGER PRIMARY KEY,
name TEXT,
email TEXT,
gender TEXT,
contact TEXT,
dob TEXT,
address TEXT
)
""")
conn.commit()
conn.close()

6
# === Functions ===
def add_student():
if roll_var.get() == "" or name_var.get() == "":
messagebox.showerror("Error", "Roll No and Name are required")
return
conn = sqlite3.connect("students.db")
cur = conn.cursor()
cur.execute("INSERT INTO students VALUES (?, ?, ?, ?, ?, ?, ?)", (
roll_var.get(), name_var.get(), email_var.get(), gender_var.get(),
contact_var.get(), dob_var.get(), address_text.get('1.0', tk.END)
))
conn.commit()
conn.close()
fetch_data()
clear_fields()

def fetch_data():
conn = sqlite3.connect("students.db")
cur = conn.cursor()
cur.execute("SELECT * FROM students")
rows = cur.fetchall()
student_table.delete(*student_table.get_children())
for row in rows:
student_table.insert('', tk.END, values=row)
conn.close()

def clear_fields():
roll_var.set("")
name_var.set("")
email_var.set("")
gender_var.set("")
contact_var.set("")
dob_var.set("")
address_text.delete("1.0", tk.END)

def update_student():
conn = sqlite3.connect("students.db")
cur = conn.cursor()

7
 cur.execute("""
UPDATE students SET name=?, email=?, gender=?, contact=?, dob=?, address=?
WHERE roll=?
""", (
name_var.get(), email_var.get(), gender_var.get(), contact_var.get(),
dob_var.get(), address_text.get('1.0', tk.END), roll_var.get()
))
conn.commit()
conn.close()
fetch_data()
clear_fields()

def delete_student():
conn = sqlite3.connect("students.db")
cur = conn.cursor()
cur.execute("DELETE FROM students WHERE roll=?", (roll_var.get(),))
conn.commit()
conn.close()
fetch_data()
clear_fields()

def search_student():
conn = sqlite3.connect("students.db")
cur = conn.cursor()
cur.execute("SELECT * FROM students WHERE " + search_by.get() + " LIKE ?", ('%' +
search_txt.get() + '%',))
rows = cur.fetchall()
student_table.delete(*student_table.get_children())
for row in rows:
student_table.insert('', tk.END, values=row)
conn.close()

def get_cursor(event):
selected_row = student_table.focus()
content = student_table.item(selected_row)
row = content['values']
if row:
roll_var.set(row[0])

8
 name_var.set(row[1])
email_var.set(row[2])
gender_var.set(row[3])
contact_var.set(row[4])
dob_var.set(row[5])
address_text.delete("1.0", tk.END)
address_text.insert(tk.END, row[6])

# === GUI Setup ===

root = tk.Tk()
root.title("Student Management System")
root.geometry("1000x600")

# === Variables ===

roll_var = tk.StringVar()
name_var = tk.StringVar()
email_var = tk.StringVar()
gender_var = tk.StringVar()
contact_var = tk.StringVar()
dob_var = tk.StringVar()
search_by = tk.StringVar()
search_txt = tk.StringVar()

# === Manage Frame ===

manage_frame = tk.Frame(root, bd=4, relief=tk.RIDGE, bg="lightblue")
manage_frame.place(x=20, y=100, width=450, height=480)

title = tk.Label(root, text="Student Management System", font=("Arial", 20, "bold"), bg="navy",

fg="white")
title.pack(side=tk.TOP, fill=tk.X)

# Input Fields
tk.Label(manage_frame, text="Roll No", bg="lightblue").grid(row=0, column=0, pady=10, padx=10,
sticky="w")
tk.Entry(manage_frame, textvariable=roll_var).grid(row=0, column=1, pady=10, padx=10)

tk.Label(manage_frame, text="Name", bg="lightblue").grid(row=1, column=0, pady=10, padx=10,

sticky="w")

9
tk.Entry(manage_frame, textvariable=name_var).grid(row=1, column=1, pady=10, padx=10)

tk.Label(manage_frame, text="Email", bg="lightblue").grid(row=2, column=0, pady=10, padx=10,

sticky="w")
tk.Entry(manage_frame, textvariable=email_var).grid(row=2, column=1, pady=10, padx=10)

tk.Label(manage_frame, text="Gender", bg="lightblue").grid(row=3, column=0, pady=10, padx=10,

sticky="w")
gender_combo = ttk.Combobox(manage_frame, textvariable=gender_var, values=["Male", "Female",
"Other"])
gender_combo.grid(row=3, column=1, pady=10, padx=10)

tk.Label(manage_frame, text="Contact", bg="lightblue").grid(row=4, column=0, pady=10, padx=10,

sticky="w")
tk.Entry(manage_frame, textvariable=contact_var).grid(row=4, column=1, pady=10, padx=10)

tk.Label(manage_frame, text="D.O.B", bg="lightblue").grid(row=5, column=0, pady=10, padx=10,

sticky="w")
tk.Entry(manage_frame, textvariable=dob_var).grid(row=5, column=1, pady=10, padx=10)

tk.Label(manage_frame, text="Address", bg="lightblue").grid(row=6, column=0, pady=10, padx=10,

sticky="w")
address_text = tk.Text(manage_frame, height=3, width=25)
address_text.grid(row=6, column=1, pady=10, padx=10)

# Buttons
btn_frame = tk.Frame(manage_frame, bg="lightblue")
btn_frame.place(x=10, y=370, width=420)

tk.Button(btn_frame, text="Add", command=add_student, width=10).grid(row=0, column=0,

padx=10)
tk.Button(btn_frame, text="Update", command=update_student, width=10).grid(row=0, column=1,
padx=10)
tk.Button(btn_frame, text="Delete", command=delete_student, width=10).grid(row=0, column=2,
padx=10)
tk.Button(btn_frame, text="Clear", command=clear_fields, width=10).grid(row=0, column=3,
padx=10)

10
# === Detail Frame ===
detail_frame = tk.Frame(root, bd=4, relief=tk.RIDGE, bg="lightgray")
detail_frame.place(x=490, y=100, width=480, height=480)

tk.Label(detail_frame, text="Search By", bg="lightgray").grid(row=0, column=0, pady=10, padx=10,

sticky="w")
search_combo = ttk.Combobox(detail_frame, textvariable=search_by, width=10, values=["roll",
"name", "contact"])
search_combo.grid(row=0, column=1, padx=10)

tk.Entry(detail_frame, textvariable=search_txt, width=20).grid(row=0, column=2, padx=10)

tk.Button(detail_frame, text="Search", width=10, command=search_student).grid(row=0, column=3,
padx=10)
tk.Button(detail_frame, text="Show All", width=10, command=fetch_data).grid(row=0, column=4,
padx=10)

# === Table Frame ===

table_frame = tk.Frame(detail_frame, bd=4, relief=tk.RIDGE, bg="white")
table_frame.place(x=10, y=60, width=450, height=400)

scroll_x = tk.Scrollbar(table_frame, orient=tk.HORIZONTAL)

scroll_y = tk.Scrollbar(table_frame, orient=tk.VERTICAL)
student_table = ttk.Treeview(table_frame, columns=("roll", "name", "email", "gender", "contact",
"dob", "address"),
xscrollcommand=scroll_x.set, yscrollcommand=scroll_y.set)

scroll_x.pack(side=tk.BOTTOM, fill=tk.X)
scroll_y.pack(side=tk.RIGHT, fill=tk.Y)
scroll_x.config(command=student_table.xview)
scroll_y.config(command=student_table.yview)

student_table.heading("roll", text="Roll No")

student_table.heading("name", text="Name")
student_table.heading("email", text="Email")
student_table.heading("gender", text="Gender")
student_table.heading("contact", text="Contact")
student_table.heading("dob", text="D.O.B")
student_table.heading("address", text="Address")

11
student_table['show'] = 'headings'

for col in ("roll", "name", "email", "gender", "contact", "dob", "address"):

student_table.column(col, width=100)

student_table.pack(fill=tk.BOTH, expand=True)
student_table.bind("<ButtonRelease-1>", get_cursor)

# === Initialize ===

connect_db()
fetch_data()
root.mainloop()

12
 5. PROJECT SCREENSHOTS

5.1 INTERFACE OF SMS

This is a Student Management System interface designed using python's tkinter library for
GUI applications. The left section allows users to input and manage student details like roll
no, name, email, gender, contact, date of birth, and address, with buttons to add, update,
delete, or clear entries.

Fig5.1

5.2 ADDING INFORMATION

The right section displays student records in a table view and includes a search functionality
that enables filtering based on selected criteria, though it is currently empty awaiting data
input.

Fig5.2 ADD

13
5.3 UPDATED DETAILS

In this section we have updated the details of students.

Fig5.3 Update

5.4 DELETION OF ROWS

In this section we have deleted the 2nd row.

Fig5.4 Delete

14
 6.CONCLUSION & FUTURE WORK

6.1 Conclusion
The Student Management System (SMS) project successfully demonstrates how automation
can simplify the management of student records in educational institutions. By replacing
traditional paper-based systems with a digital database-driven application, the system
improves accuracy, reduces redundancy, and enhances the speed of record management tasks.
Through the integration of a back-end database (MySQL) and a programming interface
(Python, Java, or PHP), the system allows administrators and faculty to perform essential
operations like adding, updating, and viewing student data, as well as maintaining attendance
and marks. The system is flexible, scalable, and can be extended to meet the growing needs of
any school or college.
The project also serves as a practical application of database management, CRUD operations,
and real-world programming skills. While the current version focuses on the core
functionalities, it lays the foundation for further improvements and real-time applications.

6.2 Future Work

There are several ways to enhance and extend the current system:
• Add user roles and permissions (admin, teacher, student) with secure login access
• Develop a mobile app version of the system for Android/iOS
• Integrate notifications or SMS/email alerts for attendance and report cards
• Include graphical dashboards and data analytics for performance tracking
• Add fee management and payment tracking modules
• Incorporate exam scheduling and timetable management features
• Migrate the system to the cloud for remote access and better scalability

15