Schedula is an AI-powered academic timetable management system that automates scheduling, detects real-time clashes, enables faculty lecture swaps, and provides intelligent analytics for institutional optimization.
🔗 Repository: github.com/indresh404/Capstone-Project
TEST USERS: FACULTY : vaishali@gmail.com / faculty123* ADMIN : bhushan@gmail.com / admin123*
If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the TS template for information on how to integrate TypeScript and typescript-eslint in your project.
📘 Full documentation of system design, architecture, and implementation.
👉 Download / View Capstone Report
- Abstract
- Problem Statement
- Proposed Idea
- Features
- Tech Stack
- System Architecture
- Core Scheduling Engine
- Database Structure
- Setup & Installation
- Environment Variables
- Impact
- Innovation Highlights
- Challenges Faced
- What I Learned
- Conclusion
- Topics
SCHEDULA is an AI-assisted academic scheduling system designed to automate and optimize timetable generation in colleges and universities. It eliminates manual scheduling inefficiencies using a constraint-based intelligent engine, real-time conflict detection, faculty swap workflows, AI-driven analytics, and a complete cloud + DevOps deployment pipeline.
The system is built as a scalable full-stack distributed application with modern backend architecture and container orchestration.
In educational institutions:
- Timetable creation is manual and time-consuming.
- Scheduling takes weeks of administrative effort.
- Frequent issues: faculty/room/batch clashes, last-minute changes, uneven workload distribution.
- No intelligent optimization or analytics system exists.
👉 Result: Inefficient scheduling, resource wastage, and high administrative overhead.
SCHEDULA is an intelligent scheduling platform that:
Automatically generates optimized timetables using constraint-based AI logic while ensuring zero conflicts and enabling dynamic faculty collaboration.
- 🧠 AI-based timetable analysis (Groq API – LLaMA 3)
- 📅 Smart timetable generation engine
⚠️ Real-time clash detection (faculty, room, batch)- 🔄 Faculty lecture swap system with approval workflow
- 📊 Analytics dashboard (workload, rooms, subjects utilization)
- 👨🏫 Faculty personal timetable view
- 🏫 Division & batch-based scheduling
- 🗄️ PostgreSQL (Supabase) database integration
- ☁️ Scalable cloud deployment with Docker & Kubernetes
- React (Vite)
- TailwindCSS
- Framer Motion
- Recharts (analytics)
- Node.js
- Express.js
- REST APIs
- JWT authentication
- PostgreSQL (Supabase)
- Groq API (LLaMA 3 for optimization insights)
- Containerization: Docker
- Orchestration: Kubernetes (pods, services, ingress, auto-scaling)
- CI/CD: GitHub Actions
- Hosting:
- Frontend: Vercel
- Backend: Render
- User dashboards (Admin, Faculty)
- Real‑time updates via REST APIs
- Constraint‑based scheduling engine
- Clash detection & swap management
- AI integration layer
- Stores users, subjects, rooms, timetables, swap requests, attendance
- Provides optimization suggestions
- Workload balancing insights
- Pattern detection
Git Push → GitHub Actions → Docker Build → Push to Registry → Kubernetes Deploy → Vercel (FE) + Render (BE)
- Backend containers run as pods
- Service (LoadBalancer) distributes traffic
- Ingress routes external requests
- Horizontal scaling based on CPU/memory
- Self-healing (failed pods auto-restart)
User Request
↓
Ingress Controller
↓
Service (Load Balancer)
↓
Backend Pods (Node.js API)
↓
Supabase (PostgreSQL)
Benefits achieved:
- Zero‑downtime architecture
- Scalable backend deployment
- Fault tolerance and recovery
- Production‑ready for large institutions
Type: Constraint Satisfaction Problem (CSP) with greedy + randomized optimization
- No faculty overlap
- No room overlap
- No batch overlap
- Labs require 2 consecutive slots
- Tests scheduled weekly
- Balanced workload distribution
Load Data → Schedule Tests → Schedule Labs → Schedule Theory → Validate Constraints → Post Process → Fill Gaps → Insert Breaks → Save to DB
Schedula is an AI-assisted academic scheduling system that automatically generates clash-free timetables using a constraint-based scheduling engine built with Node.js, Express, and PostgreSQL.
The Timetable Engine is the core backend module of Schedula that:
- Automatically assigns lectures, labs, and tests
- Ensures zero scheduling conflicts
- Balances faculty workload
- Optimizes room and batch utilization
- Constraint Satisfaction Problem (CSP)
- Greedy Scheduling Algorithm
- Heuristic Optimization
- Occupancy Matrix (O(1) conflict checking)
- Randomized Scheduling (shuffle-based fairness)
- Block Scheduling (for labs)
- Load data from database (rooms, faculty, subjects, batches)
- Initialize occupancy tracking system
- Schedule tests (1 per batch per week)
- Schedule labs (2-slot blocks, multi-batch)
- Schedule theory lectures (balanced distribution)
- Post-process timetable (remove conflicts, fix ordering)
- Fill empty slots (FREE periods)
- Insert breaks and finalize timetable
- ⚡ Real-time clash detection
- 📅 Automatic timetable generation
- 👨🏫 Faculty-aware scheduling
- 🏫 Room & batch optimization
- 🔄 Lab block scheduling system
- 📊 Balanced workload distribution
- 🧠 AI-ready structure for optimization
Frontend → API (Express.js) → Timetable Engine → PostgreSQL (Supabase)
- Users (Admin / Faculty)
- Subjects
- Rooms
- Divisions
- Batches
- Timetable entries
- O(1) conflict detection using occupancy matrices
- Precomputed lookup maps for fast access
- Reduced DB calls using in-memory processing
- Efficient greedy assignment strategy
Generates a fully structured weekly timetable with:
- No clashes
- Balanced distribution
- Faculty-wise assignments
- Room optimization
A rule-based intelligent scheduling engine that uses constraint satisfaction and greedy optimization to generate conflict-free academic timetables in real-time.
Main tables:
- Users (admin, faculty)
- Subjects (with credit hours, type)
- Rooms (capacity, type)
- Timetable (slots, assignments)
- SwapRequests (from/to faculty, status)
- Attendance (optional extension)
All operations are transaction‑safe.
- Node.js (v18+)
- npm or yarn
- Docker (optional, for containerized backend)
- Kubernetes cluster (minikube or cloud) – optional for orchestration
git clone https://github.com/indresh404/Capstone-Project.git
cd Capstone-Projectcd backend
npm install
npm run devcd frontend
npm install
npm run devcd backend
docker build -t schedula-backend .
docker run -p 5000:5000 schedula-backendkubectl apply -f k8s/deployment.yaml
kubectl apply -f k8s/service.yaml
kubectl apply -f k8s/ingress.yamlCreate .env files for backend and frontend.
PORT=5000
SUPABASE_URL=your_supabase_url
SUPABASE_ANON_KEY=your_supabase_anon_key
GROQ_API_KEY=your_groq_api_key
JWT_SECRET=your_jwt_secret
VITE_API_BASE_URL=http://localhost:5000/api
- Reduces timetable creation time from weeks → minutes
- Eliminates human errors
- Improves room & faculty utilization
- Transparent personal schedule
- Easy swap handling
- Balanced workload distribution
- AI‑driven insights & recommendations
- Automated scheduling with real‑time control
- Analytics dashboard for resource planning
- AI‑assisted timetable optimization (Groq LLM)
- Real‑time conflict detection system
- Constraint‑based scheduling engine
- Faculty swap automation with approval
- Full DevOps pipeline (CI/CD)
- Kubernetes‑based scalable deployment
- Production‑grade, cloud‑native design
- Handling multiple scheduling constraints simultaneously
- Avoiding conflicts in real‑time system updates
- Designing scalable, loosely coupled architecture
- Ensuring fair workload distribution across faculty
- Managing distributed deployment (Docker + Kubernetes)
- Integrating AI suggestions without breaking constraints
- Full‑stack development (React + Node.js)
- REST API design & JWT authentication
- Database modeling in PostgreSQL
- AI integration with LLM APIs
- Docker containerization
- CI/CD pipelines (GitHub Actions)
- Cloud deployment (Vercel + Render)
- Kubernetes orchestration (scaling, self‑healing, load balancing)
- Distributed systems architecture
- Constraint Satisfaction Problems (CSP)
- Scalable backend design patterns
- Real‑world scheduling logic
- Constraint optimization techniques
- System performance tuning
SCHEDULA is a complete AI‑powered academic scheduling platform that replaces manual timetable creation with an intelligent, scalable, and cloud‑native system.
It integrates full‑stack development, AI analytics, and modern DevOps practices including Docker and Kubernetes orchestration, making it a production‑ready, enterprise‑grade solution for educational institutions.
SCHEDULA is an AI‑powered, cloud‑native timetable optimization system that automates scheduling, resolves conflicts, balances workload, and scales using Kubernetes‑based infrastructure.
-
Indresh – indresh404
Full-stack development, AI integration, DevOps, Docker & Kubernetes orchestration -
Komal Pandey – Komal2008 • Collaborator
Contributed to frontend development, UI/UX design, and testing