Scenario A → Monolith Small team, tight deadline, no existing infrastructure. A monolith is simple to develop, test, and deploy in a single step. Microservices or event-driven would introduce operational complexity — service discovery, distributed tracing, network latency — that a 2-person team cannot absorb. Apply the “Monolith First” principle from Section 3.4.5.

Scenario B → Microservices Eight independent teams each owning a separate domain maps directly to the microservices model: each team deploys their service independently, owns its database, and cannot break other teams’ releases. The significant operational overhead is justified because the organisational structure demands it (Section 3.4.4).

Scenario C → Event-Driven Architecture High-throughput fan-out to multiple consumers (email, SMS, audit log) is the textbook event-driven use case. Producers publish to a broker; each consumer subscribes and scales independently. Synchronous direct calls at 100,000 events/minute would create tight coupling and bottlenecks (Section 3.4.3).

Defensible alternatives:

• Scenario A: Layered/MVC is also acceptable — it is a structured monolith. The key argument to reject is microservices.
• Scenario B: A layered monolith can be defended if teams are co-located and domains are not truly independent, but it is the harder argument.
• Scenario C: Microservices with synchronous APIs would require queueing infrastructure to handle this throughput — which is effectively event-driven anyway.

Diagram 1 — Use Case Diagram

Mermaid has no native use-case diagram type; the flowchart below encodes the same information using rounded shapes for actors, rectangles for use cases inside the system boundary, and labelled arrows for «include» relationships.

flowchart LR
    Student(["👤 Student"])
    Instructor(["👤 Instructor"])
    Admin(["👤 Admin"])
    PayGateway(["⚙️ Payment Gateway\n(Stripe)"])
    VideoStorage(["⚙️ Video Storage\n(AWS S3)"])
    NotifSvc(["⚙️ Notification Service\n(SendGrid)"])

    subgraph sys ["Online Learning Platform"]
        UC_BROWSE(["Browse Courses"])
        UC_ENROL(["Enrol in Course"])
        UC_WATCH(["Watch Lecture"])
        UC_QUIZ(["Submit Quiz"])
        UC_PROGRESS(["Track Progress"])
        UC_DISCUSS(["Post Discussion"])
        UC_PAY(["Process Payment"])
        UC_NOTIFY(["Send Notification"])
        UC_GRADE(["Auto-grade Quiz"])
        UC_CREATE(["Create Course"])
        UC_UPLOAD(["Upload Lecture"])
        UC_PUBLISH(["Publish / Unpublish Course"])
        UC_ADD_QUIZ(["Add Quiz to Lecture"])
        UC_ANALYTICS(["View Analytics"])
        UC_MANAGE(["Manage User Accounts"])
        UC_APPROVE(["Approve / Reject Course"])
        UC_REPORT(["Generate Revenue Report"])
    end

    Student --- UC_BROWSE
    Student --- UC_ENROL
    Student --- UC_WATCH
    Student --- UC_QUIZ
    Student --- UC_PROGRESS
    Student --- UC_DISCUSS

    Instructor --- UC_CREATE
    Instructor --- UC_UPLOAD
    Instructor --- UC_PUBLISH
    Instructor --- UC_ADD_QUIZ
    Instructor --- UC_ANALYTICS

    Admin --- UC_MANAGE
    Admin --- UC_APPROVE
    Admin --- UC_REPORT

    UC_ENROL -->|"«include»"| UC_PAY
    UC_ENROL -->|"«include»"| UC_NOTIFY
    UC_QUIZ  -->|"«include»"| UC_GRADE
    UC_GRADE -->|"«include»"| UC_PROGRESS

    UC_PAY    --- PayGateway
    UC_UPLOAD --- VideoStorage
    UC_NOTIFY --- NotifSvc

Relationship justifications:

• Enrol in Course «include» Process Payment: every enrolment unconditionally triggers a Stripe charge — payment is mandatory, not optional.
• Enrol in Course «include» Send Notification: on every enrolment outcome (success or failure) a SendGrid email is sent — notification is part of the enrolment contract.
• Submit Quiz «include» Auto-grade Quiz: every quiz submission unconditionally triggers automatic grading — students always receive their result immediately.
• Auto-grade Quiz «include» Track Progress: every graded quiz unconditionally updates the student’s progress percentage — progress is always recalculated after a quiz result.

Diagram 2 — Class Diagram

classDiagram
    class User {
        +id: UUID
        +email: str
        +password_hash: str
        +name: str
        +created_at: datetime
        +login(email: str, password: str) bool
        +update_profile(data: dict) void
    }
    class Student {
        +preferred_language: str
        +billing_address: str
        +quiz_attempts: int
        +last_active_at: datetime
        +enrol(course_id: UUID) Enrolment
        +submit_quiz(quiz_id: UUID, answers: list) QuizResult
        +watch_lecture(lecture_id: UUID) void
        +get_progress(course_id: UUID) float
    }
    class Instructor {
        +bio: str
        +rating: float
        +bank_account_id: str
        +total_students: int
        +create_course(title: str, description: str, price: float) Course
        +upload_lecture(course_id: UUID, file: bytes) Lecture
        +publish_course(course_id: UUID) void
        +view_analytics(course_id: UUID) dict
    }
    class Admin {
        +department: str
        +permissions: list~str~
        +actions_logged: int
        +last_login_at: datetime
        +approve_course(course_id: UUID) void
        +reject_course(course_id: UUID, reason: str) void
        +manage_user(user_id: UUID, action: str) void
        +generate_revenue_report(period: str) dict
    }
    class Course {
        +id: UUID
        +title: str
        +description: str
        +price: float
        +is_published: bool
        +created_at: datetime
        +publish() void
        +unpublish() void
        +get_enrolment_count() int
        +get_completion_rate() float
    }
    class Lecture {
        +id: UUID
        +title: str
        +video_url: str
        +duration_seconds: int
        +order_index: int
        +is_free_preview: bool
        +get_video_url() str
        +mark_watched(student_id: UUID) void
    }
    class Quiz {
        +id: UUID
        +title: str
        +pass_mark: int
        +max_score: int
        +required: bool
        +time_limit_seconds: int
        +grade(answers: list) QuizResult
        +add_question(question: dict) void
        +get_pass_rate() float
        +remove_question(question_id: UUID) void
    }
    class Enrolment {
        +id: UUID
        +enrolled_at: datetime
        +status: Enum
        +progress_percent: float
        +completed_at: datetime
        +certificate_url: str
        +cancel() void
        +update_progress(lecture_id: UUID) void
        +is_completed() bool
        +get_certificate() str
    }
    class Payment {
        +id: UUID
        +amount: float
        +currency: str
        +status: Enum
        +gateway_ref: str
        +paid_at: datetime
        +charge() bool
        +refund() bool
        +get_receipt() dict
        +is_successful() bool
    }

    User <|-- Student : inheritance
    User <|-- Instructor : inheritance
    User <|-- Admin : inheritance

    Instructor "1" --> "0..*" Course : creates
    Course "1" *-- "1..*" Lecture : composition (Lecture cannot exist without Course)
    Lecture "1" *-- "0..*" Quiz : composition (Quiz cannot exist without Lecture)
    Student "1" --> "0..*" Enrolment : has
    Course "1" --> "0..*" Enrolment : receives
    Enrolment "1" *-- "1" Payment : composition (Payment belongs to Enrolment)

Diagram 3 — Sequence Diagram: Enrol in Course

sequenceDiagram
    actor Student
    participant Auth as Auth Middleware (OAuth 2.0)
    participant EnrolSvc as EnrolmentService
    participant PaySvc as PaymentService
    participant NtfSvc as NotificationService
    participant DB as PostgreSQL
    participant Stripe as Stripe (Payment Gateway)
    participant SendGrid as SendGrid (Notification)

    Student->>Auth: POST /courses/{id}/enrol (Bearer token)
    Auth->>Auth: Validate OAuth 2.0 token
    Auth->>EnrolSvc: enrol(student_id, course_id)
    EnrolSvc->>DB: SELECT * FROM enrolments WHERE student=X AND course=Y
    DB-->>EnrolSvc: [] (not enrolled)
    EnrolSvc->>DB: SELECT price FROM courses WHERE id=Y
    DB-->>EnrolSvc: price=49.99
    EnrolSvc->>PaySvc: charge(student_id, amount=49.99)
    PaySvc->>Stripe: POST /v1/charges {amount, currency, customer}

    alt Payment succeeds
        Stripe-->>PaySvc: 200 OK {id: "ch_xxx", status: "succeeded"}
        PaySvc-->>EnrolSvc: Payment(status=SUCCESS, gateway_ref="ch_xxx")
        EnrolSvc->>DB: INSERT INTO enrolments (status=ACTIVE)
        EnrolSvc->>DB: INSERT INTO payments (status=SUCCESS)
        EnrolSvc->>DB: INSERT INTO progress (progress_percent=0.0)
        DB-->>EnrolSvc: OK
        EnrolSvc->>NtfSvc: notify(student_id, "Enrolment confirmed")
        NtfSvc->>SendGrid: POST /v3/mail/send (to: student)
        SendGrid-->>NtfSvc: 202 Accepted
        NtfSvc->>SendGrid: POST /v3/mail/send (to: instructor)
        SendGrid-->>NtfSvc: 202 Accepted
        EnrolSvc-->>Auth: Enrolment{id, status=ACTIVE}
        Auth-->>Student: 201 Created {enrolment}
    else Payment fails
        Stripe-->>PaySvc: 402 {error: "card_declined"}
        PaySvc-->>EnrolSvc: Payment(status=FAILED)
        EnrolSvc->>DB: INSERT INTO payments (status=FAILED)
        DB-->>EnrolSvc: OK
        EnrolSvc->>NtfSvc: notify(student_id, "Payment failed, enrolment cancelled")
        NtfSvc->>SendGrid: POST /v3/mail/send (to: student)
        SendGrid-->>NtfSvc: 202 Accepted
        EnrolSvc-->>Auth: EnrolmentError(PAYMENT_FAILED)
        Auth-->>Student: 402 Payment Required
    end

Diagram 4 — Component Diagram

flowchart TB
    subgraph Client ["Client"]
        CLI["Web / Mobile Client"]
    end

    subgraph API ["API Layer (FastAPI)"]
        AUTH["OAuth 2.0\nAuth Middleware"]
        ROUTER["REST Router"]
    end

    subgraph Services ["Service Layer"]
        CRS["Course Service"]
        ENS["Enrolment Service"]
        PAY["Payment Service"]
        QZS["Quiz Service"]
        URS["User Service"]
        NTF["Notification Service"]
        ANA["Analytics Service"]
    end

    subgraph Data ["Data Layer"]
        DB[("PostgreSQL")]
    end

    subgraph External ["External Services"]
        STRIPE["Stripe\n(Payment Gateway)"]
        S3["AWS S3\n(Video Storage)"]
        SENDGRID["SendGrid\n(Email)"]
    end

    CLI -->|HTTPS REST| AUTH
    AUTH -->|JWT validated| ROUTER
    ROUTER --> CRS & ENS & QZS & URS & ANA
    ENS --> PAY
    ENS --> NTF
    QZS --> NTF

    CRS --> DB
    ENS --> DB
    QZS --> DB
    URS --> DB
    ANA --> DB

    PAY --> STRIPE
    CRS --> S3
    NTF --> SENDGRID