Software Engineering for EdTech: Building an LMS with PHP

Why EdTech Needs Its Own SE Lens

Educational technology is not just a CRUD (Create, Read, Update, Delete) app with a classroom theme. It is a domain with its own legal constraints, accessibility mandates, and business rules that would make most CRUD applications collapse.

Consider the difference between an e-commerce checkout and a course enrollment:

These constraints mean that generic software engineering advice must be adapted. The patterns you learn — Clean Code, TDD, DDD, microservices — all still apply, but they are applied to problems shaped by the education domain. This tutorial shows you how.

Mengapa EdTech Membutuhkan Lensa SE Tersendiri

Teknologi pendidikan bukan sekadar aplikasi CRUD (Create, Read, Update, Delete) dengan tema ruang kelas. Ini adalah domain dengan batasan hukumnya sendiri, mandat aksesibilitas, dan aturan bisnis yang akan membuat sebagian besar aplikasi CRUD runtuh.

Pertimbangkan perbedaan antara checkout e-commerce dan pendaftaran mata kuliah:

Batasan ini berarti bahwa saran rekayasa perangkat lunak generik harus diadaptasi. Pola yang Anda pelajari, yaitu Clean Code, TDD, DDD, microservices, semuanya masih berlaku, tetapi diterapkan pada masalah yang dibentuk oleh domain pendidikan. Tutorial ini menunjukkan caranya.

Core Domain Concepts

Before writing a single line of code, you must understand the ubiquitous language of an LMS. These are the nouns and verbs that domain experts (lecturers, registrars, students) use every day. Your code must speak the same language.

Key Entities in an LMS

Lifecycle of an Enrollment

Pending → Confirmed → Active → Completed
                ↓          ↓
            Dropped    Withdrawn

Each state transition has business rules:

• Pending → Confirmed: capacity available, prerequisites met, no time conflict, within enrollment window
• Confirmed → Dropped: within the add/drop period
• Active → Completed: after the academic term ends and a final grade is assigned

Understanding this lifecycle is crucial — it is not just a status column in a database. The enrollment state machine is the backbone of every LMS business process.

Konsep Domain Inti

Sebelum menulis satu baris kode pun, Anda harus memahami ubiquitous language dari sebuah LMS. Ini adalah kata benda dan kata kerja yang digunakan oleh pakar domain (dosen, petugas registrasi, mahasiswa) setiap hari. Kode Anda harus berbicara dalam bahasa yang sama.

Entitas Kunci dalam LMS

Siklus Hidup Pendaftaran

Pending → Confirmed → Active → Completed
                ↓          ↓
            Dropped    Withdrawn

Setiap transisi status memiliki aturan bisnis:

• Pending → Confirmed: kapasitas tersedia, prasyarat terpenuhi, tidak ada konflik waktu, dalam jendela pendaftaran
• Confirmed → Dropped: dalam periode tambah/kurang
• Active → Completed: setelah masa akademik berakhir dan nilai akhir diberikan

Memahami siklus hidup ini sangat penting: ini bukan sekadar kolom status di database. State machine pendaftaran adalah tulang punggung dari setiap proses bisnis LMS.

Requirements & Actors in an LMS

Let us define the system from the outside in, starting with who uses the system and what they need it to do.

Actors

1. Student — views course catalog, enrols in classes, submits assignments, views grades, communicates with lecturers.
2. Lecturer — manages class content, creates assessments, grades submissions, views class roster, communicates with students.
3. Academic Advisor (Dosen Wali / PA) — approves student study plans (KRS), monitors academic progress, provides guidance.
4. Department Head (Ketua Jurusan) — approves class offerings, manages curriculum, handles grade appeals.
5. Registrar (BAAK) — manages enrollment periods, processes add/drop requests, maintains academic records, issues transcripts.
6. System Administrator — manages user accounts, configures terms/semesters, handles system-wide settings.

Functional Requirements (Excerpt)

Non-Functional Requirements

This requirements exercise is not academic — it shapes every architectural decision that follows.

Kebutuhan & Aktor dalam LMS

Mari kita definisikan sistem dari luar ke dalam, dimulai dengan siapa yang menggunakan sistem dan apa yang mereka butuhkan.

Aktor

1. Mahasiswa: melihat katalog mata kuliah, mendaftar kelas, mengumpulkan tugas, melihat nilai, berkomunikasi dengan dosen.
2. Dosen: mengelola konten kelas, membuat penilaian, menilai pengumpulan, melihat daftar kelas, berkomunikasi dengan mahasiswa.
3. Dosen Wali / PA: menyetujui rencana studi mahasiswa (KRS), memantau kemajuan akademik, memberikan bimbingan.
4. Ketua Jurusan: menyetujui penawaran kelas, mengelola kurikulum, menangani banding nilai.
5. BAAK: mengelola periode pendaftaran, memproses permintaan tambah/kurang, memelihara catatan akademik, menerbitkan transkrip.
6. Administrator Sistem: mengelola akun pengguna, mengonfigurasi masa/semester, menangani pengaturan sistem.

Kebutuhan Fungsional (Kutipan)

Kebutuhan Non-Fungsional

Latihan kebutuhan ini tidak bersifat akademis: ini membentuk setiap keputusan arsitektur yang mengikuti.

Architecture Choice: Monolith First, Split Later

One of the most consequential decisions for an EdTech project is when to split services. Many teams jump to microservices too early, creating distributed complexity for a system that has not yet found product-market fit.

Start with a Modular Monolith

For most campus LMS projects, a modular monolith is the right starting point. Here is why:

When to Extract a Microservice

Extract a module into its own service when you answer yes to at least two:

1. The module has a different deployment rhythm (e.g., the grading module changes every semester, but the enrollment module is stable).
2. The module has different scaling needs (e.g., the file upload service for assignments needs more storage and bandwidth than the rest).
3. A separate team owns the module end-to-end and needs independent releases.
4. The module has different technology requirements (e.g., a real-time chat service needs WebSocket support via Node.js, while the rest is PHP).

A Practical Monolith Structure

src/
├── Enrollment/        # Enrollment module (this tutorial's focus)
│   ├── Domain/        # Entities, value objects, domain services
│   ├── Application/   # Use cases, DTOs, application services
│   └── Infrastructure/ # Repositories, external integrations
├── Course/            # Course catalog module
├── Assessment/        # Grading and assessment module
├── User/              # Authentication and user management
└── Shared/            # Shared kernel: value objects, interfaces

Each module has its own domain model but lives in the same codebase. This is the sweet spot: bounded contexts without distributed systems.

Pilihan Arsitektur: Monolit Dulu, Pisah Kemudian

Salah satu keputusan paling konsekuensial untuk proyek EdTech adalah kapan memisahkan layanan. Banyak tim melompat ke microservices terlalu cepat, menciptakan kompleksitas terdistribusi untuk sistem yang belum menemukan product-market fit.

Mulai dengan Modular Monolith

Untuk sebagian besar proyek LMS kampus, modular monolith adalah titik awal yang tepat. Inilah alasannya:

Kapan Mengekstrak Microservice

Ekstrak modul menjadi layanannya sendiri ketika Anda menjawab ya untuk setidaknya dua:

1. Modul memiliki ritme deployment yang berbeda (misalnya, modul penilaian berubah setiap semester, tetapi modul pendaftaran stabil).
2. Modul memiliki kebutuhan penskalaan yang berbeda (misalnya, layanan unggah file untuk tugas membutuhkan lebih banyak penyimpanan dan bandwidth daripada yang lain).
3. Tim terpisah memiliki modul secara end-to-end dan membutuhkan rilis independen.
4. Modul memiliki persyaratan teknologi yang berbeda (misalnya, layanan chat real-time membutuhkan dukungan WebSocket melalui Node.js, sementara sisanya PHP).

Struktur Monolit Praktis

src/
├── Enrollment/        # Modul pendaftaran (fokus tutorial ini)
│   ├── Domain/        # Entity, value object, domain service
│   ├── Application/   # Use case, DTO, application service
│   └── Infrastructure/ # Repository, integrasi eksternal
├── Course/            # Modul katalog mata kuliah
├── Assessment/        # Modul penilaian dan grading
├── User/              # Autentikasi dan manajemen pengguna
└── Shared/            # Shared kernel: value object, interface

Setiap modul memiliki domain model sendiri tetapi tinggal di codebase yang sama. Ini adalah sweet spot: bounded context tanpa sistem terdistribusi.

Data Model Essentials

A well-designed data model is the foundation of any LMS. Let us model the core entities and their relationships.

Key Design Decisions

Why a separate classes table? A course is a catalog entry (e.g., “Calculus I”). A class is an instance of that course offered in a specific semester with a specific lecturer (e.g., “Calculus I — Class A — Odd Semester 2025/2026 — Dr. Andi”). This separation lets you reuse the same course definition across semesters while tracking distinct class instances.

Why enrollment.status instead of soft-delete? An enrollment is not just active or deleted. It has a lifecycle: pending, confirmed, active, completed, dropped, withdrawn. The status field captures this state machine. When a student drops a class, you do not delete the row — you transition the status and record the timestamp. This preserves the audit trail.

Why a separate grades table? A student may have grades for multiple assessments (assignments, UTS, UAS) within a single enrollment. The grades table captures each one. The final_grade on the enrollments table is a computed summary — recalculated when any component grade changes.

SQL Schema (Core Tables)

CREATE TABLE students (
    id INT AUTO_INCREMENT PRIMARY KEY,
    student_code VARCHAR(20) NOT NULL UNIQUE,
    name VARCHAR(200) NOT NULL,
    email VARCHAR(100) NOT NULL UNIQUE,
    batch_year YEAR NOT NULL,
    is_active BOOLEAN NOT NULL DEFAULT TRUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);

CREATE TABLE courses (
    id INT AUTO_INCREMENT PRIMARY KEY,
    course_code VARCHAR(20) NOT NULL UNIQUE,
    name VARCHAR(200) NOT NULL,
    credits TINYINT NOT NULL CHECK (credits BETWEEN 1 AND 6),
    department VARCHAR(100) NOT NULL,
    is_active BOOLEAN NOT NULL DEFAULT TRUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);

CREATE TABLE prerequisites (
    course_id INT NOT NULL,
    prerequisite_course_id INT NOT NULL,
    minimum_grade CHAR(1) DEFAULT 'D',
    PRIMARY KEY (course_id, prerequisite_course_id),
    FOREIGN KEY (course_id) REFERENCES courses(id),
    FOREIGN KEY (prerequisite_course_id) REFERENCES courses(id)
);

CREATE TABLE lecturers (
    id INT AUTO_INCREMENT PRIMARY KEY,
    lecturer_code VARCHAR(20) NOT NULL UNIQUE,
    name VARCHAR(200) NOT NULL,
    email VARCHAR(100) NOT NULL UNIQUE,
    department VARCHAR(100) NOT NULL,
    is_active BOOLEAN NOT NULL DEFAULT TRUE
);

CREATE TABLE classes (
    id INT AUTO_INCREMENT PRIMARY KEY,
    class_code VARCHAR(20) NOT NULL,
    course_id INT NOT NULL,
    lecturer_id INT NOT NULL,
    semester VARCHAR(10) NOT NULL COMMENT 'e.g. odd, even, short',
    academic_year VARCHAR(9) NOT NULL COMMENT 'e.g. 2025/2026',
    capacity INT NOT NULL CHECK (capacity > 0),
    schedule JSON NOT NULL COMMENT 'e.g. [{"day":"monday","start":"08:00","end":"10:00"}]',
    room VARCHAR(50),
    enrollment_start DATE NOT NULL,
    enrollment_end DATE NOT NULL,
    FOREIGN KEY (course_id) REFERENCES courses(id),
    FOREIGN KEY (lecturer_id) REFERENCES lecturers(id)
);

CREATE TABLE enrollments (
    id INT AUTO_INCREMENT PRIMARY KEY,
    student_id INT NOT NULL,
    class_id INT NOT NULL,
    status ENUM('pending','confirmed','active','completed','dropped','withdrawn') NOT NULL DEFAULT 'pending',
    final_grade CHAR(1),
    enrolled_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    FOREIGN KEY (student_id) REFERENCES students(id),
    FOREIGN KEY (class_id) REFERENCES classes(id),
    UNIQUE KEY uq_student_class (student_id, class_id)
);

This schema is intentionally simple — it focuses on the core enrollment flow. A production LMS would add indexes, audit tables, grade change logs, and full-text search for the course catalog.

Esensi Model Data

Model data yang dirancang dengan baik adalah fondasi dari setiap LMS. Mari kita modelkan entitas inti dan hubungannya.

Keputusan Desain Kunci

Mengapa tabel classes terpisah? Mata kuliah adalah entri katalog (misalnya, “Kalkulus I”). Kelas adalah instance dari mata kuliah tersebut yang ditawarkan pada semester tertentu dengan dosen tertentu (misalnya, “Kalkulus I, Kelas A, Semester Ganjil 2025/2026, Dr. Andi”). Pemisahan ini memungkinkan Anda menggunakan kembali definisi mata kuliah yang sama di seluruh semester sambil melacak instance kelas yang berbeda.

Mengapa enrollment.status dan bukan soft-delete? Pendaftaran bukan hanya aktif atau dihapus. Ia memiliki siklus hidup: pending, confirmed, active, completed, dropped, withdrawn. Kolom status menangkap state machine ini. Ketika mahasiswa drop kelas, Anda tidak menghapus baris, melainkan mentransisikan status dan mencatat timestamp. Ini mempertahankan jejak audit.

Mengapa tabel grades terpisah? Seorang mahasiswa mungkin memiliki nilai untuk beberapa penilaian (tugas, UTS, UAS) dalam satu pendaftaran. Tabel grades menangkap masing-masing. final_grade pada tabel enrollments adalah ringkasan yang dihitung: dikalkulasi ulang ketika nilai komponen apa pun berubah.

Skema SQL (Tabel Inti)

CREATE TABLE students (
    id INT AUTO_INCREMENT PRIMARY KEY,
    student_code VARCHAR(20) NOT NULL UNIQUE,
    name VARCHAR(200) NOT NULL,
    email VARCHAR(100) NOT NULL UNIQUE,
    batch_year YEAR NOT NULL,
    is_active BOOLEAN NOT NULL DEFAULT TRUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);

CREATE TABLE courses (
    id INT AUTO_INCREMENT PRIMARY KEY,
    course_code VARCHAR(20) NOT NULL UNIQUE,
    name VARCHAR(200) NOT NULL,
    credits TINYINT NOT NULL CHECK (credits BETWEEN 1 AND 6),
    department VARCHAR(100) NOT NULL,
    is_active BOOLEAN NOT NULL DEFAULT TRUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);

CREATE TABLE prerequisites (
    course_id INT NOT NULL,
    prerequisite_course_id INT NOT NULL,
    minimum_grade CHAR(1) DEFAULT 'D',
    PRIMARY KEY (course_id, prerequisite_course_id),
    FOREIGN KEY (course_id) REFERENCES courses(id),
    FOREIGN KEY (prerequisite_course_id) REFERENCES courses(id)
);

CREATE TABLE lecturers (
    id INT AUTO_INCREMENT PRIMARY KEY,
    lecturer_code VARCHAR(20) NOT NULL UNIQUE,
    name VARCHAR(200) NOT NULL,
    email VARCHAR(100) NOT NULL UNIQUE,
    department VARCHAR(100) NOT NULL,
    is_active BOOLEAN NOT NULL DEFAULT TRUE
);

CREATE TABLE classes (
    id INT AUTO_INCREMENT PRIMARY KEY,
    class_code VARCHAR(20) NOT NULL,
    course_id INT NOT NULL,
    lecturer_id INT NOT NULL,
    semester VARCHAR(10) NOT NULL COMMENT 'misal: ganjil, genap, pendek',
    academic_year VARCHAR(9) NOT NULL COMMENT 'misal: 2025/2026',
    capacity INT NOT NULL CHECK (capacity > 0),
    schedule JSON NOT NULL COMMENT 'misal: [{"day":"monday","start":"08:00","end":"10:00"}]',
    room VARCHAR(50),
    enrollment_start DATE NOT NULL,
    enrollment_end DATE NOT NULL,
    FOREIGN KEY (course_id) REFERENCES courses(id),
    FOREIGN KEY (lecturer_id) REFERENCES lecturers(id)
);

CREATE TABLE enrollments (
    id INT AUTO_INCREMENT PRIMARY KEY,
    student_id INT NOT NULL,
    class_id INT NOT NULL,
    status ENUM('pending','confirmed','active','completed','dropped','withdrawn') NOT NULL DEFAULT 'pending',
    final_grade CHAR(1),
    enrolled_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    FOREIGN KEY (student_id) REFERENCES students(id),
    FOREIGN KEY (class_id) REFERENCES classes(id),
    UNIQUE KEY uq_student_class (student_id, class_id)
);

Skema ini sengaja sederhana: fokus pada alur pendaftaran inti. LMS produksi akan menambahkan indeks, tabel audit, log perubahan nilai, dan pencarian teks lengkap untuk katalog mata kuliah.

Hands-On PHP: Course Enrollment Service

Now we implement the core enrollment logic. The service must enforce these business rules:

1. Enrollment window: The current date must be between enrollment_start and enrollment_end.
2. Capacity: The class must have available seats (enrolled count < capacity).
3. Prerequisites: The student must have passed all prerequisite courses.
4. Duplicate enrollment: A student cannot enrol in the same class twice.
5. Time conflict: The class schedule must not overlap with the student’s existing confirmed classes.
6. Active student: Only active students can enrol.

Step 1: Define the Contract

<?php

declare(strict_types=1);

namespace App\Enrollment\Application;

use App\Enrollment\Domain\Exception\EnrollmentException;

interface EnrollmentServiceInterface
{
    /**
     * Enrol a student in a class.
     *
     * @throws EnrollmentException when any business rule is violated
     */
    public function enrol(int $studentId, int $classId): EnrollmentResult;
}

Every enrollment result is either a success (with the enrollment ID) or a failure (with a list of violated rules). No exceptions for business rule violations — the caller needs structured reasons.

Step 2: Value Objects and DTOs

<?php

declare(strict_types=1);

namespace App\Enrollment\Domain;

use DateTimeImmutable;

enum EnrollmentStatus: string
{
    case PENDING   = 'pending';
    case CONFIRMED = 'confirmed';
    case ACTIVE    = 'active';
    case COMPLETED = 'completed';
    case DROPPED   = 'dropped';
    case WITHDRAWN = 'withdrawn';
}

class EnrollmentResult
{
    private function __construct(
        public readonly bool $success,
        public readonly ?int $enrollmentId = null,
        public readonly array $errors = [],
        public readonly array $warnings = [],
    ) {}

    public static function success(int $enrollmentId, array $warnings = []): self
    {
        return new self(success: true, enrollmentId: $enrollmentId, warnings: $warnings);
    }

    public static function failure(array $errors): self
    {
        return new self(success: false, errors: $errors);
    }
}

class ClassSchedule
{
    public function __construct(
        public readonly string $day,
        public readonly string $start,
        public readonly string $end,
    ) {}
}

Step 3: The Domain Service

<?php

declare(strict_types=1);

namespace App\Enrollment\Domain;

use DateTimeImmutable;

class CourseEnrollmentService implements \App\Enrollment\Application\EnrollmentServiceInterface
{
    private const ENROLLMENT_LIMIT_WARNING_THRESHOLD = 3;

    public function __construct(
        private readonly EnrollmentRepositoryInterface $enrollmentRepo,
        private readonly ClassRepositoryInterface $classRepo,
        private readonly StudentRepositoryInterface $studentRepo,
        private readonly PrerequisiteRepositoryInterface $prereqRepo,
    ) {}

    public function enrol(int $studentId, int $classId): EnrollmentResult
    {
        $errors = [];
        $warnings = [];

        $student = $this->studentRepo->findById($studentId);
        if ($student === null) {
            return EnrollmentResult::failure(['Student not found.']);
        }

        $class = $this->classRepo->findById($classId);
        if ($class === null) {
            return EnrollmentResult::failure(['Class not found.']);
        }

        if (!$student->isActive) {
            $errors[] = 'Student account is not active.';
        }

        if ($this->isOutsideEnrollmentWindow($class)) {
            $errors[] = sprintf(
                'Enrollment window is closed. Open from %s to %s.',
                $class->enrollmentStart->format('Y-m-d'),
                $class->enrollmentEnd->format('Y-m-d'),
            );
        }

        if ($this->enrollmentRepo->exists($studentId, $classId)) {
            $errors[] = 'Student is already enrolled in this class.';
        }

        $currentCount = $this->enrollmentRepo->countByClassAndStatus(
            $classId,
            [EnrollmentStatus::CONFIRMED, EnrollmentStatus::ACTIVE, EnrollmentStatus::COMPLETED],
        );

        if ($currentCount >= $class->capacity) {
            $errors[] = sprintf(
                'Class is full. Capacity: %d, Current: %d.',
                $class->capacity,
                $currentCount,
            );
        }

        $remaining = $class->capacity - $currentCount;
        if ($remaining > 0 && $remaining <= self::ENROLLMENT_LIMIT_WARNING_THRESHOLD) {
            $warnings[] = sprintf(
                'Only %d seat(s) remaining in this class.',
                $remaining,
            );
        }

        $unmetPrerequisites = $this->checkPrerequisites($studentId, $class->courseId);
        if (!empty($unmetPrerequisites)) {
            foreach ($unmetPrerequisites as $prereq) {
                $errors[] = sprintf(
                    'Prerequisite not met: %s (minimum grade: %s).',
                    $prereq['course_name'],
                    $prereq['minimum_grade'],
                );
            }
        }

        $conflicts = $this->detectTimeConflicts($studentId, $class);
        if (!empty($conflicts)) {
            foreach ($conflicts as $conflict) {
                $errors[] = sprintf(
                    'Schedule conflict with %s (%s %s—%s).',
                    $conflict['class_code'],
                    $conflict['day'],
                    $conflict['start'],
                    $conflict['end'],
                );
            }
        }

        if (!empty($errors)) {
            return EnrollmentResult::failure($errors);
        }

        $enrollmentId = $this->enrollmentRepo->create($studentId, $classId, EnrollmentStatus::CONFIRMED);

        $this->enrollmentRepo->recordAuditLog($enrollmentId, 'enrollment_confirmed', [
            'student_id' => $studentId,
            'class_id'   => $classId,
        ]);

        return EnrollmentResult::success($enrollmentId, $warnings);
    }

    private function isOutsideEnrollmentWindow(ClassEntity $class): bool
    {
        $today = new DateTimeImmutable('today');
        $start = $class->enrollmentStart;
        $end = $class->enrollmentEnd;

        return $today < $start || $today > $end;
    }

    private function checkPrerequisites(int $studentId, int $courseId): array
    {
        $prerequisites = $this->prereqRepo->findByCourseId($courseId);

        $unmet = [];
        foreach ($prerequisites as $prereq) {
            $passed = $this->enrollmentRepo->hasPassedCourse($studentId, $prereq['prerequisite_course_id'], $prereq['minimum_grade']);
            if (!$passed) {
                $unmet[] = $prereq;
            }
        }

        return $unmet;
    }

    private function detectTimeConflicts(int $studentId, ClassEntity $newClass): array
    {
        $enrolledClasses = $this->enrollmentRepo->findByStudentAndStatus(
            $studentId,
            [EnrollmentStatus::CONFIRMED, EnrollmentStatus::ACTIVE],
        );

        $newSchedules = $newClass->schedules;

        $conflicts = [];
        foreach ($enrolledClasses as $enrolled) {
            $existingSchedules = $enrolled['class_schedules'];

            foreach ($newSchedules as $newSlot) {
                foreach ($existingSchedules as $existingSlot) {
                    if ($newSlot->day !== $existingSlot->day) {
                        continue;
                    }

                    if ($newSlot->start < $existingSlot->end && $newSlot->end > $existingSlot->start) {
                        $conflicts[] = [
                            'class_code' => $enrolled['class_code'],
                            'day'   => $existingSlot->day,
                            'start' => $existingSlot->start,
                            'end'   => $existingSlot->end,
                        ];
                    }
                }
            }
        }

        return $conflicts;
    }
}

Step 4: PHPUnit Test

A service with this many business rules needs thorough testing. Here is a PHPUnit test suite covering the happy path and all failure modes.

<?php

declare(strict_types=1);

namespace App\Tests\Enrollment\Domain;

use App\Enrollment\Domain\CourseEnrollmentService;
use App\Enrollment\Domain\EnrollmentResult;
use App\Enrollment\Domain\EnrollmentStatus;
use App\Enrollment\Domain\ClassEntity;
use App\Enrollment\Domain\ClassSchedule;
use DateTimeImmutable;
use PHPUnit\Framework\TestCase;

class CourseEnrollmentServiceTest extends TestCase
{
    private CourseEnrollmentService $service;
    private InMemoryEnrollmentRepository $enrollmentRepo;
    private InMemoryClassRepository $classRepo;
    private InMemoryStudentRepository $studentRepo;
    private InMemoryPrerequisiteRepository $prereqRepo;

    protected function setUp(): void
    {
        $this->enrollmentRepo = new InMemoryEnrollmentRepository();
        $this->classRepo      = new InMemoryClassRepository();
        $this->studentRepo    = new InMemoryStudentRepository();
        $this->prereqRepo     = new InMemoryPrerequisiteRepository();

        $this->service = new CourseEnrollmentService(
            $this->enrollmentRepo,
            $this->classRepo,
            $this->studentRepo,
            $this->prereqRepo,
        );
    }

    /* ---------- Happy Path ---------- */

    public function testSuccessfulEnrollment(): void
    {
        $this->studentRepo->seedActiveStudent(1, '2341720001', 'Budi Santoso');

        $schedule = new ClassSchedule('monday', '08:00', '10:00');
        $this->classRepo->seedClass(10, 'TI-3A', 101, 30, $schedule, '2026-01-01', '2026-12-31');

        $result = $this->service->enrol(1, 10);

        $this->assertTrue($result->success);
        $this->assertNotNull($result->enrollmentId);
        $this->assertEmpty($result->errors);
    }

    public function testEnrollmentReturnsWarningWhenFewSeatsRemain(): void
    {
        $this->studentRepo->seedActiveStudent(1, '2341720001', 'Budi Santoso');

        $schedule = new ClassSchedule('monday', '08:00', '10:00');
        $this->classRepo->seedClass(10, 'TI-3A', 101, 5, $schedule, '2026-01-01', '2026-12-31');

        for ($i = 2; $i <= 4; $i++) {
            $this->studentRepo->seedActiveStudent($i, "234172000{$i}", "Student {$i}");
            $this->enrollmentRepo->seedEnrollment($i, 10, EnrollmentStatus::CONFIRMED);
        }

        $result = $this->service->enrol(1, 10);

        $this->assertTrue($result->success);
        $this->assertCount(1, $result->warnings);
        $this->assertStringContainsString('2 seat(s) remaining', $result->warnings[0]);
    }

    /* ---------- Validation Failures ---------- */

    public function testEnrollmentFailsWhenStudentNotFound(): void
    {
        $result = $this->service->enrol(999, 10);

        $this->assertFalse($result->success);
        $this->assertContains('Student not found.', $result->errors);
    }

    public function testEnrollmentFailsWhenClassNotFound(): void
    {
        $this->studentRepo->seedActiveStudent(1, '2341720001', 'Budi Santoso');

        $result = $this->service->enrol(1, 999);

        $this->assertFalse($result->success);
        $this->assertContains('Class not found.', $result->errors);
    }

    public function testEnrollmentFailsWhenStudentIsInactive(): void
    {
        $this->studentRepo->seedInactiveStudent(1, '2341720001', 'Budi Santoso');

        $schedule = new ClassSchedule('monday', '08:00', '10:00');
        $this->classRepo->seedClass(10, 'TI-3A', 101, 30, $schedule, '2026-01-01', '2026-12-31');

        $result = $this->service->enrol(1, 10);

        $this->assertFalse($result->success);
        $this->assertContains('Student account is not active.', $result->errors);
    }

    public function testEnrollmentFailsWhenWindowIsClosed(): void
    {
        $this->studentRepo->seedActiveStudent(1, '2341720001', 'Budi Santoso');

        $schedule = new ClassSchedule('monday', '08:00', '10:00');
        $this->classRepo->seedClass(10, 'TI-3A', 101, 30, $schedule, '2025-01-01', '2025-01-10');

        $result = $this->service->enrol(1, 10);

        $this->assertFalse($result->success);
        $this->assertStringContainsString('Enrollment window is closed', $result->errors[0]);
    }

    public function testEnrollmentFailsWhenDuplicate(): void
    {
        $this->studentRepo->seedActiveStudent(1, '2341720001', 'Budi Santoso');

        $schedule = new ClassSchedule('monday', '08:00', '10:00');
        $this->classRepo->seedClass(10, 'TI-3A', 101, 30, $schedule, '2026-01-01', '2026-12-31');

        $this->enrollmentRepo->seedEnrollment(1, 10, EnrollmentStatus::CONFIRMED);

        $result = $this->service->enrol(1, 10);

        $this->assertFalse($result->success);
        $this->assertContains('Student is already enrolled in this class.', $result->errors);
    }

    public function testEnrollmentFailsWhenClassIsFull(): void
    {
        $this->studentRepo->seedActiveStudent(1, '2341720001', 'Budi Santoso');

        $schedule = new ClassSchedule('monday', '08:00', '10:00');
        $this->classRepo->seedClass(10, 'TI-3A', 101, 3, $schedule, '2026-01-01', '2026-12-31');

        for ($i = 2; $i <= 4; $i++) {
            $this->studentRepo->seedActiveStudent($i, "234172000{$i}", "Student {$i}");
            $this->enrollmentRepo->seedEnrollment($i, 10, EnrollmentStatus::CONFIRMED);
        }

        $result = $this->service->enrol(1, 10);

        $this->assertFalse($result->success);
        $this->assertStringContainsString('Class is full', $result->errors[0]);
    }

    public function testEnrollmentFailsWhenPrerequisitesUnmet(): void
    {
        $this->studentRepo->seedActiveStudent(1, '2341720001', 'Budi Santoso');

        $schedule = new ClassSchedule('monday', '08:00', '10:00');
        $this->classRepo->seedClass(10, 'TI-3A', 101, 30, $schedule, '2026-01-01', '2026-12-31');

        $this->prereqRepo->seedPrerequisite(101, 50, 'C');

        $result = $this->service->enrol(1, 10);

        $this->assertFalse($result->success);
        $this->assertStringContainsString('Prerequisite not met', $result->errors[0]);
    }

    public function testEnrollmentFailsWhenScheduleConflicts(): void
    {
        $this->studentRepo->seedActiveStudent(1, '2341720001', 'Budi Santoso');

        $schedule = new ClassSchedule('monday', '08:00', '10:00');
        $this->classRepo->seedClass(10, 'TI-3A', 101, 30, $schedule, '2026-01-01', '2026-12-31');

        $conflictingSchedule = new ClassSchedule('monday', '09:00', '11:00');
        $this->classRepo->seedClass(11, 'TI-3B', 102, 30, $conflictingSchedule, '2026-01-01', '2026-12-31');

        $this->enrollmentRepo->seedEnrollment(1, 11, EnrollmentStatus::CONFIRMED);

        $result = $this->service->enrol(1, 10);

        $this->assertFalse($result->success);
        $this->assertStringContainsString('Schedule conflict', $result->errors[0]);
        $this->assertStringContainsString('TI-3B', $result->errors[0]);
    }

    public function testEnrollmentFailsWithAllViolationsAtOnce(): void
    {
        $this->studentRepo->seedInactiveStudent(1, '2341720001', 'Budi Santoso');

        $schedule = new ClassSchedule('monday', '08:00', '10:00');
        $this->classRepo->seedClass(10, 'TI-3A', 101, 1, $schedule, '2025-01-01', '2025-01-10');

        $this->enrollmentRepo->seedEnrollment(2, 10, EnrollmentStatus::CONFIRMED);

        $this->prereqRepo->seedPrerequisite(101, 50, 'C');

        $result = $this->service->enrol(1, 10);

        $this->assertFalse($result->success);
        $this->assertGreaterThanOrEqual(3, count($result->errors));
    }

    public function testEnrollmentSucceedsWhenPrerequisitesAreMet(): void
    {
        $this->studentRepo->seedActiveStudent(1, '2341720001', 'Budi Santoso');

        $schedule = new ClassSchedule('tuesday', '10:00', '12:00');
        $this->classRepo->seedClass(10, 'TI-3A', 101, 30, $schedule, '2026-01-01', '2026-12-31');

        $this->prereqRepo->seedPrerequisite(101, 50, 'C');
        $this->enrollmentRepo->seedPassedCourse(1, 50, 'B');

        $result = $this->service->enrol(1, 10);

        $this->assertTrue($result->success);
        $this->assertNotNull($result->enrollmentId);
    }
}

Step 5: In-Memory Repositories for Testing

To keep the test fast and deterministic, use in-memory repositories instead of a real database.

<?php

declare(strict_types=1);

namespace App\Tests\Enrollment\Domain;

use App\Enrollment\Domain\EnrollmentRepositoryInterface;
use App\Enrollment\Domain\EnrollmentStatus;
use App\Enrollment\Domain\ClassSchedule;

class InMemoryEnrollmentRepository implements EnrollmentRepositoryInterface
{
    private array $enrollments = [];
    private array $passedCourses = [];
    private int $nextId = 1;

    public function exists(int $studentId, int $classId): bool
    {
        foreach ($this->enrollments as $enrollment) {
            if ($enrollment['student_id'] === $studentId && $enrollment['class_id'] === $classId) {
                return true;
            }
        }
        return false;
    }

    public function countByClassAndStatus(int $classId, array $statuses): int
    {
        $count = 0;
        foreach ($this->enrollments as $enrollment) {
            if ($enrollment['class_id'] === $classId && in_array($enrollment['status'], $statuses, true)) {
                $count++;
            }
        }
        return $count;
    }

    public function hasPassedCourse(int $studentId, int $courseId, string $minimumGrade): bool
    {
        $gradeRanks = ['A' => 4, 'B' => 3, 'C' => 2, 'D' => 1, 'E' => 0];

        foreach ($this->passedCourses as $passed) {
            if ($passed['student_id'] === $studentId && $passed['course_id'] === $courseId) {
                return ($gradeRanks[$passed['grade']] ?? 0) >= ($gradeRanks[$minimumGrade] ?? 0);
            }
        }
        return false;
    }

    public function findByStudentAndStatus(int $studentId, array $statuses): array
    {
        $results = [];
        foreach ($this->enrollments as $enrollment) {
            if ($enrollment['student_id'] === $studentId && in_array($enrollment['status'], $statuses, true)) {
                $results[] = [
                    'class_code'     => 'CLASS-' . $enrollment['class_id'],
                    'class_schedules' => ClassRepositoryStub::getSchedules($enrollment['class_id']),
                ];
            }
        }
        return $results;
    }

    public function create(int $studentId, int $classId, EnrollmentStatus $status): int
    {
        $id = $this->nextId++;
        $this->enrollments[$id] = [
            'id'         => $id,
            'student_id' => $studentId,
            'class_id'   => $classId,
            'status'     => $status,
        ];
        return $id;
    }

    public function recordAuditLog(int $enrollmentId, string $event, array $data): void
    {
        // In test: a no-op. In production: write to audit_logs table.
    }

    /* ---- Test Helpers ---- */

    public function seedEnrollment(int $studentId, int $classId, EnrollmentStatus $status): int
    {
        return $this->create($studentId, $classId, $status);
    }

    public function seedPassedCourse(int $studentId, int $courseId, string $grade): void
    {
        $this->passedCourses[] = [
            'student_id' => $studentId,
            'course_id'  => $courseId,
            'grade'      => $grade,
        ];
    }
}

class InMemoryClassRepository implements \App\Enrollment\Domain\ClassRepositoryInterface
{
    private array $classes = [];

    public function findById(int $classId): ?ClassEntity
    {
        if (!isset($this->classes[$classId])) {
            return null;
        }

        $data = $this->classes[$classId];
        return new ClassEntity(
            id:       $data['id'],
            courseId: $data['course_id'],
            capacity: $data['capacity'],
            schedules: $data['schedules'],
            enrollmentStart: new \DateTimeImmutable($data['enrollment_start']),
            enrollmentEnd:   new \DateTimeImmutable($data['enrollment_end']),
        );
    }

    public function seedClass(
        int $id, string $code, int $courseId, int $capacity,
        ClassSchedule $schedule, string $start, string $end,
    ): void {
        $this->classes[$id] = [
            'id'              => $id,
            'code'            => $code,
            'course_id'       => $courseId,
            'capacity'        => $capacity,
            'schedules'       => [$schedule],
            'enrollment_start' => $start,
            'enrollment_end'   => $end,
        ];
    }
}

class InMemoryStudentRepository implements \App\Enrollment\Domain\StudentRepositoryInterface
{
    private array $students = [];

    public function findById(int $studentId): ?\App\Enrollment\Domain\StudentEntity
    {
        if (!isset($this->students[$studentId])) {
            return null;
        }

        $data = $this->students[$studentId];
        return new \App\Enrollment\Domain\StudentEntity(
            id:       $data['id'],
            code:     $data['code'],
            name:     $data['name'],
            isActive: $data['is_active'],
        );
    }

    public function seedActiveStudent(int $id, string $code, string $name): void
    {
        $this->students[$id] = [
            'id'        => $id,
            'code'      => $code,
            'name'      => $name,
            'is_active' => true,
        ];
    }

    public function seedInactiveStudent(int $id, string $code, string $name): void
    {
        $this->students[$id] = [
            'id'        => $id,
            'code'      => $code,
            'name'      => $name,
            'is_active' => false,
        ];
    }
}

class InMemoryPrerequisiteRepository implements \App\Enrollment\Domain\PrerequisiteRepositoryInterface
{
    private array $prerequisites = [];

    public function findByCourseId(int $courseId): array
    {
        $results = [];
        foreach ($this->prerequisites as $prereq) {
            if ($prereq['course_id'] === $courseId) {
                $results[] = $prereq;
            }
        }
        return $results;
    }

    public function seedPrerequisite(int $courseId, int $prereqCourseId, string $minimumGrade): void
    {
        $this->prerequisites[] = [
            'course_id'           => $courseId,
            'prerequisite_course_id' => $prereqCourseId,
            'course_name'         => 'COURSE-' . $prereqCourseId,
            'minimum_grade'       => $minimumGrade,
        ];
    }
}

class ClassRepositoryStub
{
    private static array $schedules = [];

    public static function setSchedules(int $classId, array $schedules): void
    {
        self::$schedules[$classId] = $schedules;
    }

    public static function getSchedules(int $classId): array
    {
        return self::$schedules[$classId] ?? [];
    }
}

Step 6: The Domain Entities

<?php

declare(strict_types=1);

namespace App\Enrollment\Domain;

class StudentEntity
{
    public function __construct(
        public readonly int $id,
        public readonly string $code,
        public readonly string $name,
        public readonly bool $isActive,
    ) {}
}

class ClassEntity
{
    public function __construct(
        public readonly int $id,
        public readonly int $courseId,
        public readonly int $capacity,
        public readonly array $schedules,
        public readonly \DateTimeImmutable $enrollmentStart,
        public readonly \DateTimeImmutable $enrollmentEnd,
    ) {}
}

This enrollment service is framework-agnostic. It depends only on interfaces (EnrollmentRepositoryInterface, etc.), not on PDO, Eloquent, or Doctrine. You can swap the infrastructure layer — from MySQL to PostgreSQL to an API client — without touching the business logic. This is the essence of domain-driven design applied to EdTech.

To run the tests:

./vendor/bin/phpunit tests/Enrollment/Domain/CourseEnrollmentServiceTest.php

Expected output:

PHPUnit 11.x.x by Sebastian Bergmann and contributors.

..........                                                    10 / 10 (100%)

OK (10 tests, 24 assertions)

Praktik PHP: Layanan Pendaftaran Mata Kuliah

Sekarang kita implementasikan logika pendaftaran inti. Layanan ini harus menegakkan aturan bisnis berikut:

1. Jendela pendaftaran: Tanggal saat ini harus berada di antara enrollment_start dan enrollment_end.
2. Kapasitas: Kelas harus memiliki kursi tersedia (jumlah terdaftar < kapasitas).
3. Prasyarat: Mahasiswa harus lulus semua mata kuliah prasyarat.
4. Pendaftaran ganda: Mahasiswa tidak dapat mendaftar kelas yang sama dua kali.
5. Konflik waktu: Jadwal kelas tidak boleh tumpang tindih dengan kelas terkonfirmasi mahasiswa.
6. Mahasiswa aktif: Hanya mahasiswa aktif yang dapat mendaftar.

Langkah 1: Definisikan Kontrak

<?php

declare(strict_types=1);

namespace App\Enrollment\Application;

use App\Enrollment\Domain\Exception\EnrollmentException;

interface EnrollmentServiceInterface
{
    /**
     * Mendaftarkan mahasiswa ke dalam kelas.
     *
     * @throws EnrollmentException ketika aturan bisnis dilanggar
     */
    public function enrol(int $studentId, int $classId): EnrollmentResult;
}

Setiap hasil pendaftaran adalah sukses (dengan ID pendaftaran) atau gagal (dengan daftar aturan yang dilanggar). Tidak ada exception untuk pelanggaran aturan bisnis: pemanggil membutuhkan alasan terstruktur.

Langkah 2: Value Object dan DTO

<?php

declare(strict_types=1);

namespace App\Enrollment\Domain;

use DateTimeImmutable;

enum EnrollmentStatus: string
{
    case PENDING   = 'pending';
    case CONFIRMED = 'confirmed';
    case ACTIVE    = 'active';
    case COMPLETED = 'completed';
    case DROPPED   = 'dropped';
    case WITHDRAWN = 'withdrawn';
}

class EnrollmentResult
{
    private function __construct(
        public readonly bool $success,
        public readonly ?int $enrollmentId = null,
        public readonly array $errors = [],
        public readonly array $warnings = [],
    ) {}

    public static function success(int $enrollmentId, array $warnings = []): self
    {
        return new self(success: true, enrollmentId: $enrollmentId, warnings: $warnings);
    }

    public static function failure(array $errors): self
    {
        return new self(success: false, errors: $errors);
    }
}

class ClassSchedule
{
    public function __construct(
        public readonly string $day,
        public readonly string $start,
        public readonly string $end,
    ) {}
}

Langkah 3: Domain Service

<?php

declare(strict_types=1);

namespace App\Enrollment\Domain;

use DateTimeImmutable;

class CourseEnrollmentService implements \App\Enrollment\Application\EnrollmentServiceInterface
{
    private const ENROLLMENT_LIMIT_WARNING_THRESHOLD = 3;

    public function __construct(
        private readonly EnrollmentRepositoryInterface $enrollmentRepo,
        private readonly ClassRepositoryInterface $classRepo,
        private readonly StudentRepositoryInterface $studentRepo,
        private readonly PrerequisiteRepositoryInterface $prereqRepo,
    ) {}

    public function enrol(int $studentId, int $classId): EnrollmentResult
    {
        $errors = [];
        $warnings = [];

        $student = $this->studentRepo->findById($studentId);
        if ($student === null) {
            return EnrollmentResult::failure(['Mahasiswa tidak ditemukan.']);
        }

        $class = $this->classRepo->findById($classId);
        if ($class === null) {
            return EnrollmentResult::failure(['Kelas tidak ditemukan.']);
        }

        if (!$student->isActive) {
            $errors[] = 'Akun mahasiswa tidak aktif.';
        }

        if ($this->isOutsideEnrollmentWindow($class)) {
            $errors[] = sprintf(
                'Jendela pendaftaran ditutup. Buka dari %s sampai %s.',
                $class->enrollmentStart->format('Y-m-d'),
                $class->enrollmentEnd->format('Y-m-d'),
            );
        }

        if ($this->enrollmentRepo->exists($studentId, $classId)) {
            $errors[] = 'Mahasiswa sudah terdaftar di kelas ini.';
        }

        $currentCount = $this->enrollmentRepo->countByClassAndStatus(
            $classId,
            [EnrollmentStatus::CONFIRMED, EnrollmentStatus::ACTIVE, EnrollmentStatus::COMPLETED],
        );

        if ($currentCount >= $class->capacity) {
            $errors[] = sprintf(
                'Kelas penuh. Kapasitas: %d, Saat Ini: %d.',
                $class->capacity,
                $currentCount,
            );
        }

        $remaining = $class->capacity - $currentCount;
        if ($remaining > 0 && $remaining <= self::ENROLLMENT_LIMIT_WARNING_THRESHOLD) {
            $warnings[] = sprintf(
                'Hanya tersisa %d kursi di kelas ini.',
                $remaining,
            );
        }

        $unmetPrerequisites = $this->checkPrerequisites($studentId, $class->courseId);
        if (!empty($unmetPrerequisites)) {
            foreach ($unmetPrerequisites as $prereq) {
                $errors[] = sprintf(
                    'Prasyarat tidak terpenuhi: %s (nilai minimum: %s).',
                    $prereq['course_name'],
                    $prereq['minimum_grade'],
                );
            }
        }

        $conflicts = $this->detectTimeConflicts($studentId, $class);
        if (!empty($conflicts)) {
            foreach ($conflicts as $conflict) {
                $errors[] = sprintf(
                    'Bentrok jadwal dengan %s (%s %s—%s).',
                    $conflict['class_code'],
                    $conflict['day'],
                    $conflict['start'],
                    $conflict['end'],
                );
            }
        }

        if (!empty($errors)) {
            return EnrollmentResult::failure($errors);
        }

        $enrollmentId = $this->enrollmentRepo->create($studentId, $classId, EnrollmentStatus::CONFIRMED);

        $this->enrollmentRepo->recordAuditLog($enrollmentId, 'enrollment_confirmed', [
            'student_id' => $studentId,
            'class_id'   => $classId,
        ]);

        return EnrollmentResult::success($enrollmentId, $warnings);
    }

    private function isOutsideEnrollmentWindow(ClassEntity $class): bool
    {
        $today = new DateTimeImmutable('today');
        $start = $class->enrollmentStart;
        $end = $class->enrollmentEnd;

        return $today < $start || $today > $end;
    }

    private function checkPrerequisites(int $studentId, int $courseId): array
    {
        $prerequisites = $this->prereqRepo->findByCourseId($courseId);

        $unmet = [];
        foreach ($prerequisites as $prereq) {
            $passed = $this->enrollmentRepo->hasPassedCourse($studentId, $prereq['prerequisite_course_id'], $prereq['minimum_grade']);
            if (!$passed) {
                $unmet[] = $prereq;
            }
        }

        return $unmet;
    }

    private function detectTimeConflicts(int $studentId, ClassEntity $newClass): array
    {
        $enrolledClasses = $this->enrollmentRepo->findByStudentAndStatus(
            $studentId,
            [EnrollmentStatus::CONFIRMED, EnrollmentStatus::ACTIVE],
        );

        $newSchedules = $newClass->schedules;

        $conflicts = [];
        foreach ($enrolledClasses as $enrolled) {
            $existingSchedules = $enrolled['class_schedules'];

            foreach ($newSchedules as $newSlot) {
                foreach ($existingSchedules as $existingSlot) {
                    if ($newSlot->day !== $existingSlot->day) {
                        continue;
                    }

                    if ($newSlot->start < $existingSlot->end && $newSlot->end > $existingSlot->start) {
                        $conflicts[] = [
                            'class_code' => $enrolled['class_code'],
                            'day'   => $existingSlot->day,
                            'start' => $existingSlot->start,
                            'end'   => $existingSlot->end,
                        ];
                    }
                }
            }
        }

        return $conflicts;
    }
}