Clean Architecture Course

Lesson 1 • Coupling, Cohesion, and Boundaries

Explains how coupling and cohesion determine module health. Students learn to identify boundary violations before writing a single line of architecture.

Lesson 2 • What Architecture Actually Means

Defines architecture as the set of decisions that are hard to reverse. Grounds the chapter by separating design from implementation concerns.

Lesson 3 • The Cost of Bad Design

Examines how poor structure accumulates technical debt over time. Motivates the entire course by quantifying the business impact of messy codebases.

Lesson 1 • Origins and Goals of Clean Architecture

Traces Clean Architecture from Hexagonal and Onion predecessors. Clarifies the shared goal: keeping business logic independent of frameworks and infrastructure.

Lesson 2 • The Four Concentric Rings

Details Entities, Use Cases, Interface Adapters, and Frameworks layers. Each ring's allowed knowledge and responsibilities are precisely defined.

Lesson 3 • The Dependency Rule Explained

Defines the single most important rule: source code dependencies point inward only. Students practice tracing dependency arrows to validate compliance.

Lesson 1 • Designing Framework-Free Domain Objects

Teaches techniques for writing Entities with zero framework imports. Students produce plain objects that can be tested without spinning up any infrastructure.

Lesson 2 • Defining Entities in Clean Architecture

Distinguishes Clean Architecture Entities from database rows or ORM models. Establishes that Entities encapsulate critical business rules, not just data.

Lesson 3 • Entity Relationships and Aggregates

Introduces aggregate roots to manage clusters of related Entities. Students learn consistency boundaries that protect business rules across object graphs.

Lesson 1 • Interactor Pattern Implementation

Implements the Interactor class that fulfills an input port contract. Demonstrates how Interactors call Entities and delegate I/O through output ports.

Lesson 2 • Input and Output Ports

Introduces port interfaces as the contract between use cases and adapters. Students define input ports (driven) and output ports (driving) explicitly.

Lesson 3 • Use Case Composition and Reuse

Addresses scenarios where multiple use cases share sub-steps. Teaches safe composition patterns that avoid coupling use cases to each other.

Lesson 4 • Testing Use Cases in Isolation

Shows how to unit-test Interactors using mock output ports. Validates that use case logic is fully exercisable without databases or web frameworks.

Lesson 1 • Controllers and Request Mapping

Builds controllers that parse incoming requests and invoke input ports. Students keep controllers thin by moving all logic into use cases.

Lesson 2 • Presenters and Output Formatting

Implements the Presenter pattern to format use case output for delivery. Separates view-model construction from business logic entirely.

Lesson 3 • Gateways and Repository Adapters

Creates gateway classes that implement output port interfaces for persistence. Students wire real databases to use cases without polluting the core.

Lesson 4 • External Service Adapters

Wraps third-party APIs and messaging systems behind output port interfaces. Isolates the core from vendor-specific SDKs and communication protocols.

Lesson 1 • Dependency Injection and Wiring

Assembles the full object graph using dependency injection at the composition root. Shows how DI containers serve the outermost layer without leaking inward.

Lesson 2 • Web and API Delivery Mechanisms

Wires HTTP routing, serialization, and middleware to adapter controllers. Demonstrates that the same use case can serve REST, GraphQL, or CLI without changes.

Lesson 3 • Database and Persistence Configuration

Configures ORM mappings and schema migrations in the infrastructure layer. Keeps all persistence technology details outside the domain and use case rings.

Lesson 1 • Component Cohesion Principles

Applies the Reuse/Release, Common Closure, and Common Reuse principles to packaging. Students group classes into components that change for one reason.

Lesson 2 • Component Coupling Principles

Applies Acyclic Dependencies, Stable Dependencies, and Stable Abstractions principles. Students detect and break dependency cycles between components.

Lesson 3 • Architectural Boundaries Defined

Distinguishes hard boundaries (separate processes) from soft boundaries (packages). Students choose boundary strength based on change frequency and team ownership.

Lesson 4 • Modular Monolith Design

Structures a single deployable unit with strong internal module boundaries. Prepares the codebase for future extraction into services without premature distribution.

Lesson 1 • Cross-Cutting Concerns Integration

Adds logging, security, and observability without polluting the domain. Students apply decorator and middleware patterns to inject cross-cutting behavior cleanly.

Lesson 2 • Building the Domain Core First

Implements Entities and Use Cases before any infrastructure exists. Validates that the core compiles and passes tests with zero external dependencies.

Lesson 3 • Architecture Fitness Functions

Writes automated tests that verify architectural rules remain intact over time. Students embed fitness functions in CI pipelines to prevent regression.

Lesson 4 • Project Setup and Structure

Establishes folder structure, module boundaries, and build configuration for a Clean Architecture project. Decisions made here enforce the dependency rule automatically.