A

Internship Project Report

ON
“Gym_max”
SUBMITTED IN FULFILLMENT OF THE

DIPLOMA IN COMPUTER ENGINEERING

(A.Y. 2025 – 2026)

Submitted By
Shaikh Faizal Ajam (236010307106)

Under the Guidance of

Nilofar Mirza

DEPARTMENT OF COMPUTER ENGINEERING

[Link] TECHNICAL INSTITUTE,

KOSAMBA-MAHUVEJ ROAD, AT [Link],

[Link] (GUJARAT)

1
 [Link] TECHNICAL INSTITUTE,
KOSAMBA-MAHUVEJ ROAD, AT [Link],

[Link] (GUJARAT)

CERTIFICATE

This is to certify that Shaikh Faizal Ajam of Diploma in Computer Engineering

(5th semester), and Enrollment no. 236010307106 has satisfactorily completed his

project entitled Gym_Max Using python using django

Date:

Signature of Guide Department in-Charge

Signature of Principal

2
 ACKNOWLEDGEMENT

This project has been the most practical exciting part of my learning experience,
which would be an asset for me and for my future career.

No system is created entirely by individual. Many people have helped to create this
system and each of their contribution has been valuable. Proper organization of
concept and analysis of system is due to keen interest and helping of my teacher and
colleagues.

My sincere thanks to our Director MR. M. M. DALCHAVAL and our principal MR.
D. V. PATEL molding my through and vision towards all subject.

I am deeply thankful to Mr. M. I. Pandor Head of Department, who is a constant

source of internship during this project.

My most sincere thanks to my project guide Nilofar Mirza

for his kind of co-operation and who has always been guiding encouraging and
motivating me through the project.

3
 ABSTRACT
This project details the development of a comprehensive Gym Management System
(GMS) designed to resolve the administrative inefficiencies and operational challenges
faced by modern fitness centers. The primary objective is to automate and centralize key
business processes using contemporary web technologies.
The system is developed leveraging the robust Python programming language and the
secure, high-level Django web framework. The GMS architecture incorporates several
essential modules: Membership Management (handling registration, renewal, and plan
tracking), Secure Payment Processing (automated invoicing and transaction records), and
Attendance Tracking for both members and staff.
By replacing traditional manual record-keeping with a secure, database-driven
application, the GMS significantly reduces administrative workload, enhances data
accuracy, and provides administrators with a centralized dashboard for performance
insights. Ultimately, this system delivers an improved digital experience for members and
empowers gym management to achieve greater operational efficiency and scalability in a
competitive market.

4
 INDEX
SR.
CONTENT PAGE. NO.
NO.

1 Introduction 7

SRS (Software Requirement and Specification)

2 8
2.1 Software Requirement 2.2. Hardware Requirement

Technology
3 9

4 Advantage of Technology 11

5 Features of Gym_Max 12

6 Types / Any related topic of Gym_Max 13

7 System Design ( ER / DFD) 15

8 Coding & Screenshot 17

9 Advantages & Disadvantages of project 32

10 Future Scope 33

11 Conclusion 34

12 Bibliography 35

5
 Learning Objectives (About Technology)

 Internship is generally thought of to be reserved for college students looking to gain experience
in a particular field. However, a wide array of people can benefit from Training Internships in
order to receive real world experience and developed their skills
 An objectives for this position should emphasize the skills you already posses in the area and
your interest in learning more
 Internship are utilized in a number of different career fields, including architecture, engineering,
healthcare, economics, advertising and many more.
 Some internship is used to allow individuals to perform scientific research while other is
specification designed to allow people to gain first-hand experience working.
 Learning Objectives : Identify the primary components of the Power BI interface: reports,
data, and model views Import Excel data and build basic visuals Publish a desktop report to the
Power BI Service

6
 Chapter – 1

Introduction

The Gym Management System is a web-based application designed to streamline and

digitize the daily operations of a gym or fitness center. Built using the Django web
framework in Python, the system provides an efficient and centralized platform for
managing member registrations, trainer assignments, workout plans, attendance tracking,
and payment processing.
In traditional gyms, member data, plans, and attendance are often managed manually,
which can lead to errors, inefficiencies, and delays. This project solves that problem by
providing an easy-to-use digital platform where Admins can manage the entire gym,
Members can view their progress and plans, and Trainers can keep track of assigned
members and schedules.
The system improves organization, enhances customer experience, and reduces the
workload on gym staff by automating many routine processes. It is scalable and can be
further extended with additional features such as notifications, analytics, and payment
gateways

7
 Chapter – 2

SRS (Software Requirement and Specification)

2.1 Software Requirement

2.1.1 Operating System: Windows 10 / 11,
2.1.2 Programming Language: Python 3.x
2.1.3 Web Framework: Django (a Python-based web framework)
2.1.4 Frontend: HTML5, CSS3, Bootstrap (for responsive design)
2.1.5 Database: SQLite (default Django database, suitable for small to
medium-sized applications)
2.1.6 Browser Compatibility: Google Chrome, Mozilla Firefox, Microsoft
Edge (latest versions recommended)
2.1.7 Other Tools:
[Link] Git (version control)
[Link] pip (Python package manager)
[Link] Code editor (e.g., VS Code, PyCharm)

2.2. Hardware Requirement

2.1 Development

Machine

 Processor: Minimum 1 GHz or faster processor

 RAM: Minimum 2 GB (4 GB or more recommended)
 Storage: At least 500 MB for codebase, database, and media files

Server / Deployment

 Processor: Minimum 1 vCPU (virtual CPU core)

 RAM: Minimum 1 GB (2 GB or more recommended for production)
 Disk Space: Minimum 1 GB (scalable based on data and media)

Client-Side

 Device: Desktop, laptop, tablet, or smartphone

 Internet: Stable internet connection
 Browser: Any modern web browser

8
 Chapter – 3
Technology

The Gym Management System project is developed using the Django framework, which is a high-level
web framework in Python. Below is a brief overview of the main technologies used in the project:

1. Python

 Python is a powerful, interpreted, and high-level programming language.

 It is widely used for web development, data analysis, artificial intelligence, and automation.

 Django is built on Python, making the codebase clean, readable, and efficient.

2. Django Framework

 Django is a free and open-source web framework that follows the Model-View-Template (MVT)
architecture.

 It handles much of the hassle of web development, such as user authentication, database
operations, and admin interfaces.

 Django comes with built-in tools to manage routing, ORM (Object Relational Mapping), form
handling, and admin dashboards.

3. HTML, CSS, and Bootstrap

 HTML (HyperText Markup Language) is used to create the structure of web pages.

 CSS (Cascading Style Sheets) is used to style HTML elements, ensuring a clean and visually
appealing design.

 Bootstrap is a CSS framework that allows for responsive, mobile-first UI design. It helps speed up
the design process with pre-built components like forms, buttons, and navigation bars.

4. SQLite Database

 SQLite is a lightweight relational database used for development.

 It stores data in a local .db file and is supported out-of-the-box by Django, making setup and
testing easy.

9
5. JavaScript (Optional Enhancements)

 JavaScript is used for basic interactivity in the frontend, such as form validation or dynamic UI
elements.

 Can be enhanced with libraries like jQuery if needed.

6. Visual Studio Code / PyCharm

 These are the IDEs (Integrated Development Environments) used to write and manage the project
code.

 They provide code intelligence, debugging tools, and easy terminal integration.

10
 Chapter – 4
Advantage of Technology

Efficient Member Management: Admins can easily manage member records, update details,
and monitor activity.

Trainer Assignment: Trainers can be assigned to specific members, improving personalized

2. training.

Plan Tracking: Tracks various membership plans (monthly, yearly), and associates them with
3. users.

4. Attendance Logging: Helps in recording and monitoring member attendance digitally.

Secure Authentication: User login and registration are handled securely using Django’s built-
5. in system.

6. User-Friendly Interface: Simple and intuitive frontend for all users (admin, trainer, member).

Centralized Data: All data (members, trainers, payments) is stored in one place, making
7. access and updates easier.

Scalable: The system can be extended with more features like payments, diet plans, or mobile
8. apps.

9. Open Source: No licensing costs; can be customized freely.

Built-in Admin Panel: Django provides a powerful auto-generated admin interface for
10. managing backend data.

11
 Chapter – 5
Features

1. User Login & Registration

2. Member Management

3. Trainer Management

4. Membership Plan Management

5. Attendance Tracking

6. Payment Tracking

7. Admin Dashboard

8. Django Admin Interface

9. Responsive Frontend Design

12
 Chapter – 6
Types / Any related topic Gym_max

1. Admin

o Has full access to the system.

o Manages members, trainers, plans, attendance, and payments.

2. Trainer

o Assigned to members.

o Views member profiles, helps with workout plans, and tracks attendance.

3. Member

o Registers for a plan.

o Views assigned trainer, attendance records, and payment history.

Types of Membership Plans

1. Monthly Plan

o Valid for 30 days.

o Common for new or casual members.

2. Quarterly Plan

o Valid for 3 months.

o Offers discounts compared to monthly.

3. Half-Yearly Plan

o 6-month plan with more benefits.

4. Yearly Plan

o Long-term plan with maximum benefits and lowest cost per month.

13
Types of Functional Modules

1. User Module

o Handles registration, login, and role-based access.

2. Membership Module

o Manages plan creation, assignment, and expiry.

3. Trainer Module

o Manages trainer profiles and assignments.

4. Attendance Module

o Logs daily attendance and provides history.

5. Payment Module

o Tracks payment status and records.

6. Dashboard Module

o Displays real-time data summary for admin.

�Related Topics

 Django MVT Architecture

 Role-Based Access Control (RBAC)

 CRUD Operations

 Database Normalization

 Secure Web Application Design

 Responsive UI Design using Bootstrap

14
 Chapter – 7
System Design ( ER / DFD)

ER Diagram

15
0 Level DFD(Data Flow Diagram)

1 Level DFD(Data Flow Diagram)

16
 Chapter – 8
Coding & Screenshot

My project has been developed using a combination of frontend and backend

technologies to ensure both an attractive user interface and a robust backend system.

 Frontend Development:
The frontend of the project is built using HTML, CSS, Bootstrap, and JavaScript.
These technologies help create a responsive and user-friendly interface, ensuring a
smooth user experience across different devices.

 Backend Development:
For the backend, I have used Python with the Django framework. Django provides
powerful tools for building secure, scalable, and maintainable web applications. It
manages all server-side logic, including user authentication, database interaction,
and form handling.

Authentication

 Users: The database contains several users, including an admin and multiple users
prefixed with 'faizal'.

 Customer Records: Three customer records exist, identified by UUIDs (e.g., 5090eb55...,
bc5e17d8...).

 Trainers: Three trainers are currently recorded: Rajesh Kumar (Weight Training), Priya
Sharma (Cardio & Fat Burn), and Sneha Reddy (Yoga & Flexibility).

 Membership Plans: Five plans are defined, ranging from Basic Plan (30 days) to Yearly
Plan (365 days) and Premium Plan (180 days).

This project appears to be a functional web application ready for presentation, covering all major
aspects of a small-to-medium gym's operations.

17
Login & Registration Process (With OTP Verification)

1. Login Required

o To continue, the user must log in.

2. New User? Register First

o If the user is not registered, they can create an account by filling out the
following details:

 📧 Email ID
 📱 Mobile Number
 🔐 Password
 🔐 Confirm Password

3. OTP Verification

o After filling all the fields, the user will receive an OTP (One-Time
Password) for verification.

o The OTP is sent to verify the email or mobile number for security.

Successful Verification

o After entering the correct OTP, the user is redirected to the login page.

This system ensures secure and complete user authentication using OTP.

18
Admin Panel
The Admin Panel is the control center of the Gym_max website. It allows the
administrator to manage every essential part of the system securely and efficiently.

1. User Interaction Features

 Registration & Login: Secure process for new users (web_customer) to register and log in,
including OTP verification.

 Inquiries & Callbacks: Customers can submit requests for information about plans or ask
for a callback. This includes tracking the request status (e.g., 'pending', 'continue',
'cancelled').

2. Core Gym Features

 Membership Plans: Customers can view the different plans available (like Basic, Yearly,
Premium) along with their duration and price details.

 Membership Enrollment: Manages the sign-up process for a selected plan, updating the
customer's membership status with start and end dates.

 Payment Processing: Records financial transactions (web_payment) linked to the customer

and their membership plan.

 Workout Scheduling: Allows trainers to set and customers to view their personalized
workout appointments (date, time, workout type), often linked to a specific trainer.

3. Application Modules (The Big Picture)

These are the main components that hold the features together, as Gym_max:
1. Project Title/Goal
2. Project Aim
3. Project Technologies Used (Django, SQLite, etc.)
4. Project Authentication (Login/Registration/OTP)
5. Main Features (The list above)
6. Main Modules (e.g., Trainer, Payment, Membership Modules

19
Screenshots of Admin Panel :

(Figure 1.1 Admin panel)

(Figure 1.2 Admin panel)

20
(Figure 1.3 Admin panel)

(Figure 1.4 Admin panel)

21
(Figure 1.5 Admin panel)

(Figure 1.6 Admin panel)

22
Code:-

[Link]

from [Link] import admin

from [Link] import *

# Register your models here.

from [Link] import admin

from .models import Customer

@[Link](Customer)
class CustomerAdmin([Link]):
list_display = ('id', 'first_name', 'last_name', 'email', 'mobile', 'is_active')
list_filter = ('is_active',)
search_fields = ('first_name', 'last_name', 'email', 'mobile')
list_editable = ('is_active',)
ordering = ('-id',)

@[Link](Trainer)
class TrainerAdmin([Link]):
list_display = (
'fullname',
'email',
'phone',
'gender',
'specialty',
'experience_years',
'joining_date',
'is_active'
)
list_filter = ('gender', 'specialty', 'joining_date')
search_fields = ('fullname', 'email', 'phone', 'specialty')
readonly_fields = ('joining_date', 'profile_image_preview')
fieldsets = (
('Basic Info', {
'fields': ('fullname', 'email', 'phone', 'gender', 'dob', 'address')
}),
('Professional Info', {
'fields': ('specialty', 'experience_years', 'bio', 'joining_date')

23
 }),
('Profile Picture', {
'fields': ('profile_image', 'profile_image_preview')
}),
)

def profile_image_preview(self, obj):

if obj.profile_image:
return f'<img src="{obj.profile_image.url}" width="100" height="100" style="object-fit:
cover;" />'
return "(No image)"
profile_image_preview.allow_tags = True
profile_image_preview.short_description = 'Profile Image Preview'

@[Link](MembershipPlan)
class MembershipPlanAdmin([Link]):
list_display = ('name', 'duration_days', 'price', 'create_at')
search_fields = ('name',)
list_filter = ('duration_days',)
ordering = ('price',)

@[Link](Inquiry)
class InquiryAdmin([Link]):
list_display = ('customer', 'plan', 'status')
list_filter = ('status', 'plan')
search_fields = ('customer first_name', 'customer last_name', 'plan name')

@[Link](CustomerMembership)
class CustomerMembershipAdmin([Link]):
list_display = ('customer', 'plan', 'start_date', 'end_date', 'is_active')
list_filter = ('is_active', 'plan', 'start_date', 'end_date')
search_fields = ('customer first_name', 'customer last_name', 'plan name')
ordering = ('-start_date',)
autocomplete_fields = ['customer', 'plan']

@[Link](WorkoutSchedule)
class WorkoutScheduleAdmin([Link]):
list_display = ('customer', 'trainer', 'date', 'time', 'workout_type')
list_filter = ('workout_type', 'date', 'trainer')
search_fields = ('customer first_name', 'customer last_name', 'trainer name',
'workout_type')
ordering = ('-date', '-time')
autocomplete_fields = ['customer', 'trainer']

@[Link](Payment)
class PaymentAdmin([Link]):
24
 list_display = ('customer', 'plan', 'amount', 'payment_method', 'payment_date')
list_filter = ('payment_method', 'payment_date', 'plan')
search_fields = ('customer first_name', 'customer last_name', 'plan name')
ordering = ('-payment_date',)
autocomplete_fields = ['customer', 'plan']

@[Link](CallBackRequest)
class CallBackRequestAdmin([Link]):
list_display = ('name', 'phone', 'email', 'status', 'submitted_at')
list_filter = ('status', 'submitted_at')
search_fields = ('name', 'phone', 'email')
ordering = ('-submitted_at',)

[Link]
#!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys

def main():
"""Run administrative tasks."""
[Link]('DJANGO_SETTINGS_MODULE', '[Link]')
try:
from [Link] import execute_from_command_line
except ImportError as exc:
raise ImportError(
"Couldn't import Django. Are you sure it's installed and "
"available on your PYTHONPATH environment variable? Did you "
"forget to activate a virtual environment?"
) from exc
execute_from_command_line([Link])

if name == ' main ':

main()

25
[Link]

from [Link] import models

import uuid

class BaseClass([Link]):
id = [Link](primary_key=True, blank=False, null=False, default=uuid.uuid4)
create_at = [Link](auto_now_add=True)
update_at = [Link](auto_now=True)

class Meta:
abstract = True

class Customer(BaseClass):
first_name = [Link](max_length=255, blank=True, null=False, default='-')
last_name = [Link](max_length=255, blank=True, null=False, default='-')
email = [Link](max_length=255, blank=False, null=False)
mobile = [Link](max_length=255, null=False, blank=False)
password = [Link](max_length=255, null=False, blank=False)
otp = [Link](max_length=20, blank=False, null=False, default="112233")
is_active = [Link](default=False)

class Trainer(BaseClass):
GENDER_CHOICES = (
('Male', 'Male'),
('Female', 'Female'),
('Other', 'Other'),
)

fullname = [Link](max_length=255)
email = [Link](unique=True)
phone = [Link](max_length=15)
gender = [Link](max_length=10, choices=GENDER_CHOICES, default='Male')
dob = [Link](null=True, blank=True)
address = [Link](blank=True)
profile_image = [Link](upload_to='trainer_profiles/', null=True, blank=True)
specialty = [Link](max_length=255)
experience_years = [Link](default=0)
bio = [Link](blank=True)
joining_date = [Link](auto_now_add=True)
is_active = [Link](default=True)

def str (self):

26
 return [Link]

class MembershipPlan(BaseClass):
name = [Link](max_length=100)
duration_days = [Link]() # e.g., 30, 90, 180
price = [Link](max_digits=10, decimal_places=2)
description = [Link](blank=True)

def str (self):

return f"{[Link]} - {self.duration_days} days"

class Inquiry([Link]):
STATUS_CHOICES = [
('pending', 'Pending'),
('contacted', 'Contacted'),
('completed', 'Completed'),
('continue', 'Continue'),
('rejected', 'Rejected'),
('cancelled', 'Cancelled'),
]
customer = [Link](Customer, on_delete=[Link],
related_name='inquiries')
plan = [Link](MembershipPlan, on_delete=[Link],
related_name='inquiries')
status = [Link](max_length=20, choices=STATUS_CHOICES, default='pending')

def str (self):

return f"Inquiry from {[Link].first_name} {[Link].last_name} for
{[Link]} ({[Link]})"

class CustomerMembership(BaseClass):
customer = [Link](Customer, on_delete=[Link])
plan = [Link](MembershipPlan, on_delete=[Link])
start_date = [Link]()
end_date = [Link]()
is_active = [Link](default=True)

def str (self):

return f"{[Link]} - {[Link]}"

class WorkoutSchedule(BaseClass):
customer = [Link](Customer, on_delete=[Link])
trainer = [Link](Trainer, on_delete=models.SET_NULL, null=True)
date = [Link]()
27
 time = [Link]()
workout_type = [Link](max_length=100) # e.g., Cardio, Strength
notes = [Link](blank=True)

def str (self):

return f"{[Link]} - {self.workout_type} on {[Link]}"

class Payment(BaseClass):
customer = [Link](Customer, on_delete=[Link])
plan = [Link](MembershipPlan, on_delete=models.SET_NULL, null=True)
amount = [Link](max_digits=10, decimal_places=2)
payment_date = [Link](auto_now_add=True)
payment_method = [Link](max_length=50, default='Online') # e.g., Cash, Card,
UPI

def str (self):

return f"{[Link]} - ₹{[Link]}"

class CallBackRequest(BaseClass):
STATUS_CHOICES = [
('new', 'New'),
('in_progress', 'In Progress'),
('called', 'Called'),
('closed', 'Closed'),
]

name = [Link](max_length=255)
phone = [Link](max_length=20)
email = [Link]()
message = [Link]()
status = [Link](max_length=20, choices=STATUS_CHOICES, default='new')
submitted_at = [Link](auto_now_add=True)

def str (self):

return f"{[Link]} - {[Link]} - {self.get_status_display()}"

28
 Screenshots:-

Login page

Home page

29
Trainers page

Contact page

30
Membership page

31
 Chapter – 9

Advantages & Disadvantages of Project

Advantages of the Gym Max System

 Rapid Development

 Automatic Admin Interface

 Strong Security

 Clear Modular Structure

 Simple Database Management

Disadvantages of the Gym Max System

 Scalability Limitations

 External OTP Dependency

 Complex Deployment

 Limited Customization

32
 Chapter – 10

Future Scope

Customer Management & Access

 Secure Accounts: Handles customer registration, login, and profile management.

 Verification: Implements OTP Verification for new customer accounts.

 Trainer Management: Maintains detailed profiles for trainers, including their specialty.

Sales & Membership

 Plans: Defines and manages all membership plans (e.g., Basic, Yearly) with pricing and
duration.

 Enrollment: Tracks customer membership status, start dates, and end dates.

Operations & Scheduling

 Workouts: Manages the creation and tracking of workout schedules, linking customers and
trainers.

 Leads: Captures and tracks the status of customer inquiries and callback requests.

Financial Recording

 Payments: Records all transaction details, including amount, date, and payment method,
linking them to a specific membership purchase

33
 Chapter – 11

Conclusion
The Gym Max System (g13_gym_max) successfully delivers an integrated, modular solution for
core gym operations. Built on Django 5.2.3, the project effectively manages secure customer
onboarding with OTP verification, handles complex data relationships for trainer assignment and
membership enrollment, and provides robust tracking for payments and inquiries. While the
current reliance on SQLite limits enterprise-level scaling, the architecture is scalable and easily
transferable to a production database like PostgreSQL. Overall, the system achieves its goal of
streamlining gym management through comprehensive digital features, ready for immediate
deployment and refinement.

34
 Chapter – 12
Bibliography

1. Gym_max Bibliography (Internal File References)

2. .gitignore

3. db.sqlite3 (SQLite Database File)

4. LICENSE (MIT License)

5. [Link] (Django Project Startup Script)

6. New Text [Link] (Presentation Outline)

7. [Link] (Project Title/Description)

8. [Link] (Project Dependencies/Versions)

35