Cloud Computing Mini Project Report on

Student Management System

Submitted in partial fulfillment of the requirements of
the

THIRD YEAR OF ENGINEERING IN COMPUTER

ENGINEERING

By

Neha Rajio Bhad 02

Diya Bhanushali 05
Shreya Bhuvad 09

Name Of The Mentor

Prof. Pallavi Bharambe

Department of Computer Engineering

Shivajirao S. Jondhale College of Engineering.
Dombivli (E)
(Affiliated to University of Mumbai)
(AY 2024-25)
 CERTIFICATE

This is to certify that the Synopsis on Cloud Computing Project

entitled “Student management system” is a bonafide work of Neha
Bhad(02), Diya Bhanushali(05), Shreya Bhuvad(09) submitted to
the University of Mumbai in partial fulfillment of the requirement for
the award of the degree of “Bachelor of Engineering” in
“Computer Engineering”.

Prof. Pallavi Bharambe

Mentor
Contents

1 Introduction

2 Application

3 Methodology

4 Code

5 Results

6 Conclusion
 Introduction
This report presents the design and implementation of a Student Management System developed as
a part of the Cloud Computing project. The primary objective of this project is to leverage cloud-based
technologies to efficiently manage and maintain student records, streamline administrative tasks, and
enhance data accessibility and security.

Cloud computing has revolutionized the way data is stored, processed, and accessed. By hosting the
Student Management System on the cloud, the project ensures scalability, high availability, and ease
of access from any location. The system is designed to handle core functionalities such as student
registration, academic record management, attendance tracking, and performance analysis. The
integration of cloud infrastructure not only simplifies system maintenance but also provides robust
data backup and recovery mechanisms.

This report outlines the system architecture, cloud deployment strategy, tools and technologies used,
and the practical implications of adopting a cloud-based approach. The project demonstrates the
potential of cloud computing in modernizing educational administration and offers a scalable solution
suitable for institutions of various sizes
Application
The hosted application offers several functionalities:

1. Firebase Authentication Module

• Purpose: Ensures only registered users can access or modify student data.
• Functionalities:
Register:

• User enters an email and password.

• Registers the user via Firebase Authentication.
Login:

• Authenticates user credentials using Firebase.

• On success, grats access to the student management interface.
2. Student Management GUI

• Main Form Fields:

• Student ID
• Student Name
• Branch Name

Buttons:

• Save: Adds new student data to Firebase Realtime Database.

• Update: Updates the student data based on ID.

3. Firebase Realtime Database

Purpose: Stores and retrieves student data in real-time.
Data Structure:
Example:

• ID: 1
• name: "Shreya"
• b_name: "Comps"
Each student entry is stored with a unique key generated by Firebase.
Fields include: ID: Student ID, name: Student name, b_name: Branch name

4. Flow of the Application:

1. User Registration/Login
→ Secure access using Firebase Authentication
2. On Successful Login
→ User sees the main window for managing student data.
3. Add Student (Save)
→ Enters ID, Name, Branch → Clicks Save → Data stored in Firebase Realtime DB.
4. Update Student
→ Enters ID and updated details → Clicks Update → Firebase record is modified.
5. Display Data
→ Fetches and shows all students from Firebase DB.

Benefits of Cloud Hosting

• Accessibility: Users can access the application from anywhere via a web browser without
requiring local installations.

• Scalability: The cloud server handles multiple concurrent users efficiently.

• Collaboration: Teams can work on shared datasets without transferring files manually
Methodology
The project is a Student Management System built using Python, Tkinter for GUI, and
Firebase for backend database and authentication. Below is the detailed
methodology:
1. Authentication Module

• Purpose: To secure access to the system by authenticating users.

User Registration:
Users can register by providing an email and password through the register.py
interface.
The registration data is sent to Firebase Authentication for secure account creation.
A success or error message is displayed based on the outcome.
• User Login: Users log in using their registered email and password via
login.py.
• On successful login: Users can either manage student records or view
existing data.

2. Student Data Management

• Purpose: To allow users to add, update, and view student records.

• Steps:
1. Adding Student Records (student1.py):
- Users input student details like ID, Name, and Branch.
- Input validation ensures:
ID is numeric.
Name and Branch contain only alphabets.
- On clicking "Save," the record is pushed to Firebase Realtime Database under a
unique key.

2. Updating Student Records (student1.py):

- Users can modify existing student details by entering the updated values.
- On clicking "Update," the corresponding record in Firebase is updated.

3. Viewing Student Records (display.py):

- All student records are retrieved from Firebase and displayed in a tabular
format using Tkinter's Treeview widget.
- Users can see details like Student ID, Name, and Branch.
3.Firebase Integration
• Purpose: To store and retrieve data securely in real time.
• Steps:
1. Authentication:
- Firebase Authentication manages user login and registration securely.
2. Realtime Database:
- Stores student records under a parent node (fb).
- Each record has fields: ID, name, and b_name (branch name).
3. Data Retrieval and Updates:
• Data is fetched dynamically from Firebase when viewing or updating records.

4.Tools & Technologies Used

• Frontend (GUI): Python’s Tkinter library.
• Backend Storage: Firebase (for user registration) / Local in-memory or
filebased storage.
• Development Environment: VS Code / PyCharm

5. Workflow
Code
1.Firebase Configuration: const firebaseConfig = { apiKey:

"AIzaSyCn_J7ddCwVNJhNs1e8_elvJkv3OCb9TTs", authDomain:

"student-management-syste-37a5a.firebaseapp.com",

databaseURL:"https://student-management-syste-37a5a-

default.rtdb.firebaseio.com", projectId: "student-management-syste-

37a5a", storageBucket: "student-management-syste-

37a5a.firebasestorage.app", messagingSenderId: "624907262540",

appId: "1:624907262540:web:a1d7c348a69373903db2e9"

};

2.Display.py from tkinter import *

from tkinter.messagebox import *

from tkinter.ttk import Treeview

from pyrebase import * import re

class

StudentManagementSystemd:

def __init__(self, root):

self.root = root

self.root.title("Student Management System")

self.root.geometry("800x700+50+50")

firebaseConfig = {
 "apiKey": "YOUR_API_KEY",

"authDomain": "student-8ec27.firebaseapp.com",

"databaseURL": "https://student-8ec27-default-rtdb.firebaseio.com/",

"projectId": "student-8ec27",

"storageBucket": "student-8ec27.appspot.com",

"messagingSenderId": "827852263219",

"appId": "1:827852263219:web:2896d18208ed510b103846",

"measurementId": "G-QZG2Y66DEE"

# Initialize Firebase self.fb = initialize_app(firebaseConfig)

self.db = self.fb.database() t = ("Century", 25, "bold", "italic")

f = ("Arial", 15, "bold", "italic") v = ("Arial", 10, "bold") labtitle

= Label(root, text=" Student Management System", font=t)

#labtitle.place(x=100, y=30) self.labID =

Label(root, text="Enter Student ID", font=f)

#self.labID.place(x=50, y=100) self.entID = Entry(root,

font=f, width=20) #self.entID.place(x=300, y=100)

self.labName = Label(root, text="Enter Student Name",

font=f)

#self.labName.place(x=50, y=200) self.entName =

Entry(root, font=f, width=20) #self.entName.place(x=300,

y=200) self.labSalary = Label(root, text="Enter Branch

Name", font=f)

#self.labSalary.place(x=50, y=300) self.entSalary =

Entry(root, font=f, width=20) #self.entSalary.place(x=300,

y=300) self.btnUpdate = Button(root, text="Update", font=f,

width=10)

#self.btnUpdate.place(x=400, y=400) self.btnSave =

Button(root, text="Save", font=f, width=10)

#self.btnSave.place(x=200, y=400) # Add Treeview widget to display

data self.tree = Treeview(root, columns=('ID', 'Name', 'Branch'),

show='headings') self.tree.heading('ID', text='ID')

self.tree.heading('Name', text='Name') self.tree.heading('Branch',

text='Branch') self.tree.place(x=30, y=10,width=750,height=560)

# Call method to load data into

Treeview self.load_data() def

load_data(self):

# Clear existing data from Treeview

for item in self.tree.get_children():

self.tree.delete(item)

# Fetch data from Firebase and populate

Treeview student_records =
self.db.child("fb").get().val() if student_records:

for key, value in student_records.items():

if isinstance(value, dict): # Check if value is a dictionary

self.tree.insert('', 'end', values=(value.get('ID', ''), value.get('name', ''),

value.get('b_name', ''))) if __name__ == "__main__":

root = Tk()

app = StudentManagementSystemd(root)

root.mainloop()

3.login.py from tkinter import *

from tkinter.messagebox import

* from pyrebase import *

from student1 import student from register

import student10 from display import

StudentManagementSystemd

# Firebase configuration

firebaseConfig = {

"apiKey": "AIzaSyDdkCDL4VEFTCKdD_P24A5ichL8U-zfD2E",

"authDomain": "student-8ec27.firebaseapp.com",

"databaseURL": "https://student-8ec27-default-rtdb.firebaseio.com/",

"projectId": "student-8ec27",
 "storageBucket": "student-8ec27.appspot.com",

"messagingSenderId": "827852263219",

"appId": "1:827852263219:web:2896d18208ed510b103846",

"measurementId": "G-QZG2Y66DEE"

# Initialize Firebase fb =

initialize_app(firebaseConfig) auth =

fb.auth() root = Tk() root.title("Student

Management System")

root.geometry("400x180+500+200")

def register():

new_window=Toplevel(root)

app=student10(new_window)

def login():

email = entry_email.get()

password = entry_password.get()

try:

user = auth.sign_in_with_email_and_password(email,

password) showinfo("Success", "Login Successful!")

open_main_window() except Exception as e:

showerror("Error", "Login Failed!\n" + str(e))

def open_main_window():
new_window=Toplevel(root)

app=student(new_window)

# You can place your main application window code here

def login1():

email = entry_email.get()

password = entry_password.get()

try:

user = auth.sign_in_with_email_and_password(email,

password) showinfo("Success", "Login Successful!")

open_main_window1() except Exception as e:

showerror("Error", "Login Failed!\n" + str(e)) def

open_main_window1(): new_window=Toplevel(root)

app=StudentManagementSystemd(new_window) label_email =

Label(root, text="Email:") label_email.pack() entry_email =

Entry(root) entry_email.pack() label_password = Label(root,

text="Password:") label_password.pack() entry_password =

Entry(root, show="*") entry_password.pack() button_login =

Button(root, text="Login", command=login) button_login.pack()

button_login = Button(root, text="Register", command=register)

button_login.pack() button_login = Button(root, text="Display

Data", command=login1) button_login.pack() root.mainloop()

Results
Login Page:

This is the login screen of the Student Management System. It allows existing users to securely
access the system by entering their registered email and password. The authentication
process is handled using Firebase Authentication. When the user clicks the Login button, the
app sends the credentials to Firebase to verify them. If the credentials match, the user is
redirected to the dashboard; otherwise, an error message is shown. This step ensures that
unauthorized users cannot access the student records

Register Page:
The registration screen enables new users to create an account. It includes fields for entering
a name, email, and password. Once the Register button is clicked, the entered data is sent to
Firebase Authentication where the user account is created and stored securely. This also
includes error handling (e.g., if an email already exists or password is weak). The registered
user can then proceed to log in and manage student data, maintaining secure access control.

Dashboard (Student Entry Form):

This is the main dashboard where users can input and manage student data. It contains text
fields for Student ID, Name, and Branch. The Add Data button sends this information to
Firebase Realtime Database or Firestore and stores it in a structured format. There’s also an
Update Data feature that modifies an existing record if the ID already exists. This form allows
users to perform Create and Update operations in the student database, forming the heart of
the system's CRUD functionality.

Display Page + Plus Chatbot:

The display section of the Student Management System is the core area where users can add,
update, and view student information. It includes input fields for entering the Student ID,
Name, and Branch, along with buttons to perform Add or Update operations. When a user
submits this data, it is sent to Firebase Realtime Database, where it's stored or updated in real
time under a unique key. Just below the form, there's a table that dynamically displays all the
student records currently stored in the database.

On the same screen, the system also features an integrated chatbot that allows users to
interact with the student data using natural language. Users can type questions like “How
many students are in IT?” or “List all CSE students,” and the chatbot processes these queries
using predefined logic. It communicates with Firebase, retrieves the relevant data based on
the question, and responds with accurate results in a conversational style. This feature adds
an intelligent and modern layer to the system, making it more accessible—especially for users
who prefer asking questions instead of navigating through forms and tables. The chatbot
enhances usability and makes data access faster, especially for summarizing or filtering
information.
Firebase Service (Authentication):

In the Student Management System, the authentication module plays a vital role in ensuring
secure access to the application. It allows only verified users to log in using their email and
password credentials, which are managed through Firebase Authentication. When a user
signs up or logs in, their identity is verified by Firebase, and upon successful authentication,
they are granted access to the system. This helps protect sensitive data such as student
records from unauthorized access. Each authenticated user is assigned a unique User UID,
which the system uses to identify and manage user-specific data within the Realtime
Database. For example, once a user logs in, the system can retrieve and display their
personalized dashboard, such as student data, branch details, and even chatbot interaction
history.

Firebase Service (Realtime Database):

When a user adds a student from the GUI, the data (ID, name, and branch) is pushed to
Firebase under the "fb" node, where Firebase auto-generates a unique key. This helps in
uniquely identifying each student while maintaining a clean and organized data tree. The
application uses this data to display records on the front-end dynamically. Additionally, the
chatbot also interacts with this same data structure—when a user types a question like “Show
students in Comps,” the app searches the name field across all child nodes and returns the
matching results using the chatbot interface. This seamless communication between the UI,
chatbot, and Firebase makes the system both interactive and intelligent
Conclusion
The development of the Student Management System using Firebase has proven to be highly efficient,
secure, and scalable. Firebase Authentication simplifies user login and registration, ensuring secure
access for each user. Realtime Database enables instant data storage, retrieval, and synchronization,
making student record management seamless and dynamic. The integration of Firebase into the
Python-based GUI application enhances functionality while reducing backend complexities.

This project demonstrates how cloud technologies like Firebase can significantly simplify the
development process of data-driven applications. It is ideal for academic or institutional purposes
where student data must be managed efficiently. Overall, Firebase not only accelerates development
but also ensures reliability, real-time performance, and scalability—making it a perfect choice for
modern educational tools.

By leveraging Firebase, this system eliminates the need for traditional server-side infrastructure,
reducing costs and development time. Its cloud-based architecture ensures that data is always backed
up and accessible from anywhere, making it ideal for institutions operating in hybrid or remote
learning environments. The smooth integration of user authentication and real-time data handling
provides a professional-level experience while keeping the application lightweight and easy to
maintain. This project serves as a solid foundation for future enhancements such as role-based access,
analytics, and mobile app integration.