A full-stack University Management System built with FastAPI, MySQL, and Docker, featuring JWT authentication, role-based access control, async database operations, load testing, and VPS production deployment.

The project includes a lightweight frontend dashboard built with HTML/CSS/JavaScript for testing and interacting with the API.

• 🔐 JWT Authentication
• 🛡️ Role-Based Access Control
• ⚡ Async FastAPI + Async SQLAlchemy
• 🐳 Dockerized Backend & Database
• 📚 Course Management
• 👨‍🎓 Student Management
• 👩‍🏫 Faculty Management
• 🔗 Enrollment System
• 🧪 Full Async Pytest Suite
• 📈 k6 Load Testing & Benchmarking
• 🌐 VPS Production Deployment
• 🔒 HTTPS + Nginx Reverse Proxy
• 🚦 Rate Limiting using SlowAPI

Frontend:

https://ums.dhruvcore.com/

A simple frontend dashboard is included using:

• HTML
• CSS
• JavaScript

• Signup & Login
• Create Courses
• Create Students
• Create Faculty
• Create Enrollments
• JWT Protected API Calls

This frontend is a basic API interaction dashboard, not a production UI.

University-Management/
│
├── backend/
│   ├── core/
│   ├── db/
│   ├── dependencies/
│   ├── migrations/
│   ├── models/
│   ├── queries/
│   ├── routes/
│   ├── schemas/
│   ├── services/
│   ├── tests/
│   └── main.py
│
├── frontend/
├── docker/
├── requirements.txt
├── docker-compose.yml
├── README.md
└── LICENSE

git clone https://github.com/Dhruv-Cmds/University-Management.git
cd University-Management

python -m venv .venv

.venv\Scripts\activate

source .venv/bin/activate

pip install -r requirements.txt

Create a .env file:

COMPOSE_PROJECT_NAME=ums-app

DB_NAME=ums
TEST_DB_NAME=ums_test
DB_USER=ums_user
DB_PASSWORD=ums_password
MYSQL_ROOT_PASSWORD=ums_password

SECRET_KEY=your_secret_key
ALGORITHM=HS256
ACCESS_TOKEN_EXPIRE_MINUTES=60

CREATE DATABASE ums;

uvicorn backend.main:app --reload

Swagger Docs:

http://127.0.0.1:8000/docs

docker compose up --build

API Docs:

http://localhost:8002/docs

Protected routes require:

Authorization: Bearer <your_token>

This project is deployed on a Linux VPS using Docker, Nginx, HTTPS, and a production-style reverse proxy setup.

• Hostinger VPS
• Ubuntu 24.04
• Dockerized FastAPI backend
• Dockerized MySQL database
• Nginx reverse proxy
• HTTPS enabled with Certbot + Let's Encrypt
• Domain-based deployment

• FastAPI
• Async SQLAlchemy
• JWT Authentication
• Role-Based Access Control
• Gunicorn + Uvicorn workers
• Dockerized API container

• HTML/CSS/JavaScript dashboard
• Served behind Nginx
• Connected to protected backend APIs using JWT

• MySQL 8
• Dedicated Docker container
• Persistent Docker volume
• Separate test database support

• HTTPS enforced
• SSH key-based VPS access
• UFW firewall configured
• JWT-protected routes
• bcrypt password hashing
• Nginx reverse proxy isolation
• Rate limiting with SlowAPI
• Environment variables separated from source code

git push origin main
        ↓
SSH into VPS
        ↓
git pull
        ↓
docker compose up --build -d
        ↓
Nginx routes traffic to FastAPI container
        ↓
HTTPS served through Let's Encrypt

Run async pytest suite:

pytest -v

• JWT authentication
• Role-based access control
• CRUD operations
• Database integration
• Enrollment flow
• Protected routes
• Async route testing

The API was stress-tested using k6 against a fully containerized environment:

• FastAPI running in Docker
• MySQL running in Docker
• Async SQLAlchemy + aiomysql
• JWT Authentication
• bcrypt password hashing
• Rate limiting enabled
• Mixed authenticated CRUD workloads

• 2 vCPU
• 8GB RAM
• Ubuntu 24.04
• Dockerized environment
• FastAPI backend
• MySQL database
• Nginx reverse proxy
• HTTPS enabled

• Admin signup
• Admin login
• Course creation
• Student creation
• Faculty creation
• Enrollment creation
• Authenticated GET endpoints
• Concurrent database writes
• JWT-protected API access
• Role-based protected routes

• Tested up to 1000 virtual users
• Stable behavior observed under normal production-style load
• Authenticated API flows completed successfully
• Database remained operational during load testing
• Containers stayed responsive during sustained traffic
• No catastrophic crashes observed

• ~100–300 realistic concurrent active users

• ~300–700 concurrent virtual users

At aggressive loads beyond 700 concurrent VUs:

• Increased latency observed
• Higher response times on write-heavy endpoints
• bcrypt hashing became a visible bottleneck during login/signup
• MySQL write pressure increased
• Some failed/slow requests appeared under extreme load
• No full system crash observed
• Services remained operational

Run load tests:

k6 run load_test.js

Benchmark suite includes:

• Admin signup/login
• JWT generation
• Course creation
• Student creation
• Faculty creation
• Enrollment creation
• Authenticated GET endpoints
• Concurrent database writes
• Protected role-based routes

Recommended production command:

gunicorn backend.main:app \
  -k uvicorn.workers.UvicornWorker \
  -w 4 \
  -b 0.0.0.0:8000

• Clean architecture:

routes → services → queries → models

• Dependency Injection using FastAPI
• Async database operations
• Stateless JWT authentication
• Foreign key constraints
• Service-layer business logic
• Async test isolation
• Dockerized infrastructure
• Production deployment using Nginx and HTTPS

fastapi
sqlalchemy
aiomysql
uvicorn
gunicorn
pydantic
python-jose
passlib
bcrypt
pytest
pytest-asyncio
httpx
slowapi
docker

• React frontend migration
• Admin analytics dashboard
• Email notifications
• Refresh tokens
• Redis caching
• Prometheus + Grafana monitoring
• Background task queue
• Database replication
• Horizontal scaling

Licensed under the MIT License.

Dhruv
GitHub: https://github.com/Dhruv-Cmds

This project was built as a real-world backend engineering practice project demonstrating:

• API architecture
• JWT authentication
• RBAC authorization
• async FastAPI patterns
• Dockerized deployment
• database integration
• load testing
• production-style backend design