Clean Architecture Masterclass

Practical, pragmatic, and realistic Clean Architecture certification training for Java developers building large-scale applications.

Introduction

This training will guide you through the major architectural styles and patterns for backend systems, including Clean Architecture, Hexagonal Architecture, Layered Architecture, Vertical Slices Architecture, Domain-Driven Design, Modular Monoliths, and Microservices. By understanding every style and its trade-offs, you’ll learn how to combine them in your application while avoiding common pitfalls. Guided by real-world Java examples, you’ll learn how to:

Design clean and pragmatic architecture

Slice and structure your application by Features.

Group code by the axis of change.

Organize code in functional top-level packages.

Find package boundaries (heuristics).

Remove cyclic dependencies between packages (6 strategies).

Separate module/compilation units.

Decouple modules/packages/components with Dependency Inversion.

Reduce cognitive load with modularity and information hiding.

Enforce architectural constraints.

Isolate the core application logic from the infrastructure.

Test your core logic, infrastructure, and integrations.

Segregate data structures and DB Schemas.

Balance between uniformity/standardization and pragmatism.

Leverage Evolutionary Architecture and avoid big up-front designs.

Incrementally migrate from legacy Big Ball of Mud to Modulith/Microservices.

Design clean services and domain model

Apply SOLID Principles and Five Rules of Simple Design.

Masterfully balance coupling and cohesion.

Make your code speak the domain language.

Separate the core domain from subdomains.

Decouple domains with APIs and events.

Design rich domain entities (OOP done right).

Protect domain objects’ invariants (strategies).

Decouple the domain from the infrastructure, API, and persistence.

Create an Anti-Corruption Layer with Adapter pattern.

Test-drive the domain with fast unit tests.

Map the domain to the API DTOs (and stay away from auto-mappers).

Separate logic by Layers of Abstraction.

Design Application Services, Controllers, and Façades.

Logically separate commands from queries with CQRS.

Improve query performance by using a separate read model.

Keep write and read models in sync.