CampusRSO

Universities frequently struggle with fragmented and manual systems for scheduling shared campus resources such as lecture halls, laboratories, and specialized equipment. Different faculties maintain their own spreadsheets or ad-hoc booking methods, leading to persistent double-booking conflicts, administrative bottlenecks, and significant underutilization of expensive facilities. Existing solutions like MRBS or generic Google Workspace calendars provide basic scheduling but lack the enterprise-grade multi-tenancy required by modern universities - they cannot natively enforce database-level data isolation between faculties that share the same infrastructure.There is no unified platform that allows faculties to operate independently while still sharing resources across the university, leading to poor visibility into campus-wide utilization and missed optimization opportunities.

CampusRSO addresses this by providing a cloud-native, microservices-based web platform where each faculty operates as an independent tenant with strict data isolation enforced at both the application layer (Firebase Custom Claims) and database layer (Supabase PostgreSQL Row Level Security). The system uses five independently deployable backend services — Tenant, User, Resource, Booking, and Notification — built with Node.js, TypeScript, and Fastify, communicating asynchronously via Redis Streams. A React + TypeScript frontend delivers role-specific dashboards. Automated conflict detection prevents double-bookings, a priority-based bumping system resolves scheduling conflicts, and real-time in-app plus email notifications keep all users informed. The entire platform is containerized with Docker and deployed on Kubernetes (K3s) using ArgoCD for GitOps-based continuous delivery, behind an Nginx API gateway with TLS termination and rate limiting.

Overview : CampusRSO is a microservices-based, multi-tenant web platform designed for managing shared university campus resources (lecture halls, laboratories, and specialized equipment) across multiple faculties. It replaces fragmented manual booking systems with a unified, secure, and scalable solution.

Architecture : The platform follows a microservices architecture with five core backend services: 1. Tenant Service - Faculty/department CRUD and configuration 2. User Service - User profiles, signup, role management, and Firebase Custom Claims 3. Resource Service - Resource catalog management and real-time availability checking 4. Booking Service - Booking CRUD, approve/reject workflow, priority-based conflict detection, and optimization logging 5. Notification Service - In-app notifications, email delivery via Resend API, and Redis event consumption

All services are built with Node.js 22, TypeScript, and the Fastify framework, sharing common middleware (authentication, error handling, logging) through a shared library (@rso/shared). Services communicate asynchronously using Redis Streams for event-driven, decoupled coordination.

Multi-Tenancy & Security : Each university faculty operates as an independent tenant. Data isolation is enforced at two layers: 1. Application layer — Every API request is scoped by tenant_id extracted from Firebase JWT Custom Claims 2. Database layer — Supabase PostgreSQL Row Level Security (RLS) policies ensure queries only access data belonging to the authenticated user's tenant

Role-Based Access Control (RBAC) supports five roles: Student, Lecturer, Staff, Tenant Admin, and Super Admin.

Key Features : - Real-time resource availability with calendar-based views - Automated booking conflict detection with priority-based bumping - Approval/rejection workflows for tenant administrators - Student Token Economy - a points-based credit system for managing equipment borrowing quotas - Peer-to-Peer Student Borrowing - students can list personal items for others to borrow using tokens - In-app + email notifications powered by Redis Streams and the Resend API - Role-specific dashboards with utilization analytics and optimization logs (Recharts)

Frontend : The frontend is built with React 19, TypeScript, Vite, and React Router v7. It features 12 page modules covering authentication, dashboards, resource browsing, booking management, notifications, admin panels, user management, tenant management, student resources, and student borrowing. Icons are provided by Lucide React and charts by Recharts.

DevOps & Deployment : - Containerization: Each service has its own Dockerfile; the full stack runs via Docker Compose - Orchestration: Production deployment on Kubernetes (K3s) with Kustomize overlays - GitOps: ArgoCD monitors the repository and automatically syncs deployments - CI/CD: GitHub Actions pipeline automates linting, testing (Jest unit tests + Puppeteer E2E tests), building Docker images, and pushing to the container registry - Gateway: Nginx reverse proxy with rate limiting and TLS termination via Cloudflare Origin Certificates - DNS/TLS: Cloudflare with Full (Strict) SSL mode

Testing : - Unit tests: Jest + ts-jest covering all six service modules - End-to-end tests: Puppeteer-based browser automation testing full user flows - RLS verification scripts to validate database-level tenant isolation

Methodology : The project was developed following Agile principles with iterative sprints and continuous integration.

Results & Future Work : The platform successfully demonstrates a production-ready, multi-tenant campus resource management system with automated conflict resolution, real-time notifications, and GitOps-based deployment. Future enhancements include AI-driven resource optimization, a dedicated mobile application (React Native/Flutter), academic timetable/LMS integration, and an advanced analytics dashboard for campus-wide utilization tracking.