Enrollify — College Enrollment Management System

Table of Contents

• System Summary
• Screenshots
• System Architecture
• Domain-Driven Design & Clean Architecture
• Tech Stack & Libraries
• System Goals
• Author

System Summary

Enrollify replaces fragmented, manual enrollment processes with a unified role-based web system. It supports the complete academic operations cycle across multiple user roles and student types.

User Roles

Modules & Functional Coverage

Master Data

• Buildings & Rooms — room type catalog, physical room management (capacity, type, building)
• Colleges & Departments — academic organizational hierarchy
• Courses (Programs) — degree programs (e.g., BS Computer Science), linked to departments and colleges
• Subjects — academic units with units, codes, and discipline assignments
• Equivalent Subject Mappings — cross-college or cross-curriculum subject equivalences (used for transferees)

Curriculum Management

• Curriculum versioning per course and academic year
• Subject prerequisites (hard and advisory) with prerequisite chain validation
• Curriculum-based subject grouping by year level and semester

Academic Calendar

• Academic year and semester/term management
• Enrollment period windows per semester

Class Scheduling

• Class section management (e.g., BSCS-2A) linked to courses and year levels
• Subject offerings per section with teacher and room assignment
• Class schedule management with automatic conflict detection (room and teacher double-booking)
• Bulk class section initialization

Enrollment

Enrollify supports three student enrollment workflows:

• Regular Students — select a class section and automatically enroll in all section offerings
• Irregular Students — manually add individual subject offerings across year levels or sections
• Transferee Students — credit evaluation using equivalent subject mappings; enroll in remaining required subjects

Enrollment features include:

• Prerequisite completion checks (with registrar/advisor override)
• Capacity enforcement (with Dean/Registrar override)
• Outstanding balance validation with assessment clearance flags
• Enrollment status lifecycle: Pending → Approved → Enrolled
• Subject Opening Request workflow for under-enrolled subjects
• Certificate of Registration (CoR) generation per term

Finance

• Assessment & fee calculation engine (tuition + miscellaneous fees)
• Tuition fee package management per course/year level
• Miscellaneous fee assignment rules (per subject, per course, per semester)
• Payment processing with partial payment support
• Balance tracking and payment history
• Cashier portal with receipt generation (PDF)

Academic Records

• Grade encoding portal for teachers (midterm + final grades)
• Registrar-level grade management and override
• Academic standing and GPA computation
• Transcript of Records (ToR) and CoR generation as PDF documents

Portals

• Student Portal — view enrolled subjects, class schedules, grades, and payment status; request documents
• Parent/Guardian Portal — read-only view of academic and financial status

Platform & Security

• Role-Based Access Control (RBAC) with fine-grained permission flags per role
• Azure Active Directory (Entra ID) authentication via MSAL
• System audit logs for all critical operations
• File upload with virus scan support

Glossary

Screenshots

System Architecture

Enrollify is structured as a single-page application (SPA) frontend backed by a REST API on .NET 10, with Azure-hosted infrastructure.

┌─────────────────────────────────────────────────────────┐
│                    React 19 SPA (Frontend)               │
│              TanStack Router · TanStack Query            │
│               shadcn/ui · Tailwind CSS v4                │
└────────────────────────┬────────────────────────────────┘
                         │ HTTPS (REST / JSON)
┌────────────────────────▼────────────────────────────────┐
│             .NET 10 Web API (Backend)                    │
│         FastEndpoints · Mediator (CQRS) · EF Core        │
└──────┬────────────────────────┬────────────────────────-┘
       │                        │
┌──────▼───────┐       ┌────────▼──────────┐
│  Azure SQL   │       │  Azure Blob        │
│  (SQL Server)│       │  Storage           │
└──────────────┘       └───────────────────┘
 
Authentication: Azure Active Directory (Entra ID / MSAL)
CI/CD: GitHub Actions → Azure DevOps → Azure App Service

Mono-repo Layout

Enrollment-System/
├── src/
│   ├── system/
│   │   ├── EnrollifyBackend/          # .NET 10 Web API (7 projects)
│   │   └── enrollify-frontend/        # React 19 TypeScript SPA
│   └── POCs/
│       ├── Enrollify.CleanArchPOC/    # Clean Architecture reference POC
│       └── Genetic-algorithm/         # GA-based class scheduling solver (POC)
├── docs/
│   ├── user-stories/                  # US-001 → US-031 feature specs
│   ├── requirements/                  # Development phases & domain models
│   ├── sql-notes/                     # DB design notes and validation rules
│   └── Notes/                         # Research and algorithm notes
├── plans/                             # Design & implementation plans
└── research/                          # Technical research documents

Domain-Driven Design & Clean Architecture

The backend is built following Domain-Driven Design (DDD) and Clean Architecture using Ardalis patterns. The design enforces strict separation of concerns through layered projects — domain logic never depends on infrastructure.

Architectural Layers

Sample File Structure

EnrollifyBackend/
├── Enrollify.Core/
│   ├── Aggregates/
│   │   ├── SubjectAggregate/
│   │   │   ├── Subject.cs             # Aggregate root
│   │   │   ├── SubjectId.cs           # Vogen strongly-typed ID
│   │   │   └── SubjectCode.cs         # Vogen value object
│   │   ├── CollegeAggregate/
│   │   ├── CourseAggregate/
│   │   ├── CurriculumAggregate/
│   │   ├── ClassSectionAggregate/
│   │   └── ...                        # 15 aggregates total
│   ├── ValueObjects/
│   ├── DomainExceptions/
│   └── IAuditable.cs
│
├── Enrollify.Application/
│   ├── Features/
│   │   ├── Subjects/
│   │   │   ├── CreateSubject.cs       # Command + Handler (inner class)
│   │   │   ├── GetSubjects.cs         # Query + Handler + Spec
│   │   │   └── SubjectDTO.cs
│   │   ├── Colleges/
│   │   ├── Courses/
│   │   └── ...
│   ├── Filtering/
│   │   ├── FilterExpressionBuilder.cs
│   │   └── SpecSortBuilder.cs
│   └── PagedResult.cs
│
├── Enrollify.Infrastructure/
│   ├── Data/
│   │   └── EnrollifyDbContext.cs
│   ├── Repositories/
│   └── Migrations/
│
├── Enrollify.WebAPI/
│   ├── Features/
│   │   ├── Subjects/
│   │   │   ├── CreateSubjectEndpoint.cs
│   │   │   ├── GetSubjectsEndpoint.cs
│   │   │   └── SubjectsGroup.cs
│   │   └── ...
│   ├── Authorization/
│   └── Program.cs
│
├── Enrollify.SharedKernel/
│   ├── EntityBase.cs
│   ├── IAggregateRoot.cs
│   └── IRepository.cs
│
└── Enrollify.DatabaseMigration/
    └── Scripts/
        └── *.sql

Key Patterns

• CQRS via Mediator: Every use case is a ICommand<T> / IQuery<T> record with an inner Handler class.
• Endpoints via FastEndpoints: Each endpoint inherits Endpoint<TRequest, TResponse>; co-located Validator<TRequest> for input validation.
• Result pattern via Ardalis.Result: Handlers return Result<T> or Result; the API layer maps them to HTTP responses.
• Strongly-typed IDs via Vogen: Entity IDs (e.g., SubjectId, SubjectCode) are source-generated structs — no accidental primitive obsession.
• Specifications via Ardalis.Specification: Paginated, filtered, and sorted queries are expressed as composable spec classes.

Tech Stack & Libraries

Backend

Frontend

System Goals

1. Digitize end-to-end enrollment — eliminate paper-based and spreadsheet-driven processes with a reliable web system accessible to all stakeholders.

2. Support all student types — handle the distinct workflows for regular, irregular, and transferee students without compromising data integrity.

3. Enforce academic rules automatically — prerequisite validation, schedule conflict detection, and enrollment capacity limits are enforced by the system, with controlled override capabilities for authorized roles.

4. Enable accurate financial management — compute and track tuition fees, miscellaneous charges, and payments with full audit trails and clearance workflows.

5. Provide role-appropriate portals — each user type (student, parent, faculty, admin) sees only the information and actions relevant to their role.

6. Maintain academic records reliably — grade encoding, GPA computation, and document generation (CoR, ToR) are handled consistently and are always traceable back to enrollment records.

7. Scale with the institution — built on Azure infrastructure with automated CI/CD, the system is designed to grow without manual deployment overhead.

Author

Raniel Garcia
Senior Software Engineer · Accenture Philippines (ATCP)
GitHub: @ranielgarcia