Preview this course
Free
Lifetime access, no cost
Sign up to enroll Already a member? Log in
Recently updated Programming

Design Patterns Mastery: From Theory to Production Code

Stop guessing which pattern fits — build the design judgment senior engineers trust in production.

3.9 (111 ratings) Created by Adam Caldwell
Intermediate 61 lessons 32h 15m Updated Jun 2026 English
Preview this course
Free
Lifetime access, no cost
Sign up to enroll Already a member? Log in

What you'll learn

Recognize the problem each design pattern solves and when (and when not) to reach for it
Apply the five SOLID principles to keep code flexible and testable
Implement all 23 Gang of Four patterns in idiomatic, production-grade Java
Read and draw UML class diagrams to communicate design intent
Combine patterns without over-engineering, and spot anti-patterns and "pattern fever"
Use architectural patterns: MVC/MVP/MVVM, layered, hexagonal/clean, and CQRS/event sourcing
Build resilient, concurrent systems with thread pools, circuit breakers, retries, bulkheads, and sagas
Structure persistence with enterprise data patterns: Active Record, Data Mapper, Repository, and Unit of Work

This course includes

32h 15m of on-demand content
61 lessons across 16 sections
Access on mobile and desktop
Certificate of completion
Lifetime access
Curriculum

Course content

16 sections · 61 lessons · 32h 15m

What Are Design Patterns (and What They Are Not) Preview 20 min
A Brief History: The Gang of Four & the Pattern Catalog Preview 15 min
UML Class Diagrams — A Practical Primer Preview 30 min
Coupling, Cohesion & the Cost of Change 25 min

Single Responsibility Principle (SRP) 25 min
Open/Closed Principle (OCP) 25 min
Liskov Substitution Principle (LSP) 20 min
Interface Segregation Principle (ISP) 20 min
Dependency Inversion Principle (DIP) 25 min

Singleton (and why it is controversial) 30 min
Factory Method 30 min
Abstract Factory 40 min

Builder 30 min
Prototype 25 min
Choosing the Right Creational Pattern 15 min

Adapter 30 min
Decorator 35 min
Facade 25 min

Composite 35 min
Proxy 30 min
Bridge 35 min
Flyweight 25 min

Strategy 35 min
Observer 40 min
Command 35 min

State 35 min
Template Method 25 min
Iterator 25 min
Chain of Responsibility 30 min

Mediator 30 min
Memento 30 min
Visitor 35 min
Interpreter 30 min

Dependency Injection & Inversion of Control 35 min
Repository, Unit of Work & DTO 30 min
Patterns in Functional & Reactive Programming 30 min
Anti-Patterns & "Pattern Fever" 30 min

Reading a System for Pattern Opportunities 40 min
Combining Patterns Without Over-Engineering 40 min
Capstone Walkthrough & Code Review Standards 100 min

MVC, MVP & MVVM 35 min
Layered (N-Tier) Architecture 30 min
Hexagonal & Clean Architecture 40 min
CQRS & Event Sourcing 40 min

Producer–Consumer 35 min
Thread Pool 35 min
Future & Promise 35 min
Read-Write Lock 30 min

Circuit Breaker 35 min
Retry & Backoff 30 min
Bulkhead & Timeout 30 min
Saga 40 min
Cache-Aside 30 min

Null Object 25 min
Object Pool 35 min
Specification 30 min
Service Locator vs Dependency Injection 30 min

Active Record 30 min
Data Mapper 35 min
Identity Map & Lazy Load 30 min
Service Layer 30 min

Requirements

  • Comfortable writing classes and methods in an object-oriented language (Java examples used throughout)
  • A basic grasp of interfaces and inheritance
  • No prior design-patterns knowledge required — it starts from first principles

Description

What you'll learn

A complete, example-driven design patterns course that takes you from "why does this code keep breaking?" to confidently choosing and implementing the right pattern in production. You'll learn the five SOLID principles, all 23 Gang of Four patterns, and the modern patterns real systems are built on — each taught with a UML diagram, a concrete scenario, and idiomatic Java.

How the course is organized

  1. Foundations & SOLID (Sections 1–2) — what patterns are, how to read UML, coupling vs cohesion, and the principles every pattern rests on.
  2. The Gang of Four (Sections 3–9) — creational, structural, and behavioral patterns, one focused lesson each, with the trade-offs that decide between them.
  3. Modern practice & capstone (Sections 10–11) — dependency injection, repositories, functional/reactive styles, anti-patterns, and a full capstone that combines patterns without over-engineering.
  4. Beyond the GoF (Sections 12–16) — architectural patterns (MVC, layered, hexagonal/clean, CQRS), concurrency patterns, cloud-resilience patterns (circuit breaker, retry, bulkhead, saga), patterns beyond the original catalog, and enterprise data patterns from PoEAA.

Who this is for

Developers who can already write object-oriented code and want to level up their design judgment — to recognize recurring problems, communicate solutions with the shared vocabulary of patterns, and know when not to use one. Start from first principles; finish able to architect and review real systems.

Topics covered

design-patterns gang-of-four oop solid software-architecture java refactoring
Your instructor
A

Adam Caldwell

Author & instructor

3.9 course rating 3 courses

Creates rigorous, project-based courses that prioritize shipping over watching. Reach out with feedback once you finish — that loop is half the value.

3.9 course rating · 111 ratings

A
Alexandrea Franecki
2 months ago

A reliable, well-made course. Lost half a star for a couple of audio/example hiccups, but still recommended.

Helpful?
  • Report this review
Z
Zora Hintz Sr.
7 months ago

Solid introduction with great real-world framing. I learned plenty and finished motivated.

Helpful?
  • Report this review
L
Luciano Welch
10 months ago

Outstanding course. The structure is fantastic and the instructor clearly knows the subject inside and out.

Helpful?
  • Report this review
A
Alexandre Koss
1 month ago

Good, dependable course. It covered what I needed, and the pacing suited me as a working professional.

Helpful?
  • Report this review

Frequently asked questions

Yes — once you enroll, the course is yours to revisit forever. New revisions and bonus lessons are added at no extra cost.

Finish every lesson and you'll unlock a shareable certificate you can post on LinkedIn or include with job applications.

If the course isn't a fit, request a refund within 7 days of purchase — no questions asked.

Code, slides, and worksheets are downloadable on each lesson page. Videos stream from our CDN so you can watch on any device.

Each course states its level in the hero. If you're comfortable with the prerequisites listed, you're ready to start.

Students also bought

Beginner
Programming

Data Engineering Bootcamp

4.2 (41)

A beginner-to-job-ready path through the core craft of data engineering: SQL from first query t...

27h 34m Ananya Iyer
₹129
Beginner
DevOps

CI/CD for Beginners

3.9 (51)

A practical, project-driven course that takes you from manual deploys to a complete automated C...

5h 46m David Okafor
₹199
Free
Sign up to enroll