Model Online / On-Site
Duration
Modules 5 modules

Course Objective & Scope

Applying design patterns by rote overcomplicates code, while ignoring them leads to rigid, untestable classes. This course connects class-level GoF patterns with application-level architectural styles through practical business scenarios.

It covers SOLID and GRASP principles, the most frequently needed creational, structural and behavioral patterns, dependency inversion, hexagonal (ports and adapters) and clean architecture layers, and architectural trade-off analysis. Participants refactor a tangled codebase step by step and produce an Architecture Decision Record (ADR) template.

Who Should Attend?

  • Mid-level and senior developers sharpening their code design skills
  • Team leads responsible for technical design and code reviews
  • Software engineers stepping into module and application architecture
  • Prerequisite: development experience in an object-oriented language (Java, C#, TypeScript, etc.)

Key Takeaways

  • Spot SOLID violations and code smells and simplify them with the right pattern
  • Apply Factory, Builder, Strategy, State, Decorator and Observer patterns where they fit
  • Decouple business logic from framework and database details with hexagonal/clean architecture
  • Draw a clear line between genuine flexibility needs and over-engineering
  • Document architectural decisions with rationale and alternatives in ADR format

Curriculum

Design Principles: SOLID, GRASP and Dependency Management
  • Cohesion, coupling and a practical reading of the SOLID principles
  • Composition over inheritance and applying Dependency Inversion
Creational and Structural Patterns
  • Object creation with Factory Method, Abstract Factory and Builder
  • Wrapping integrations and cross-cutting behaviour with Adapter, Decorator, Facade and Proxy
Modelling Business Rules with Behavioral Patterns
  • Replacing sprawling if/switch blocks with Strategy, State and Template Method
  • Chain of Responsibility, Command, Mediator and Observer patterns
  • Avoiding patternitis and hands-on refactoring exercises
Application Architecture: Layered, Hexagonal and Clean Architecture
  • Limits of classic layering and inverting dependency direction
  • Ports & Adapters (Hexagonal) and Clean Architecture module structure
  • Feature-based organisation with Vertical Slice Architecture
Architectural Decisions, Quality Attributes and ADRs
  • Balancing performance, maintainability, testability and security
  • Visualising architecture with C4 diagrams and an ADR writing workshop

Other Courses in This Category

  • Enterprise Application Architecture and Integration Patterns

    Martin Fowler's PoEAA, Enterprise Integration Patterns (EIP), distributed consistency, CQRS, modular monoliths, high availability and multi-tenancy — for architects and senior engineers designing large-scale enterprise systems.

    Web Development – Backend Corporate
    Live Course
    5 modules
    View
  • Microservices with .NET, MassTransit and .NET Aspire

    End-to-end .NET microservices with ASP.NET Core, .NET Aspire, YARP API Gateway, gRPC, MassTransit (RabbitMQ/Kafka), Polly resilience, Outbox and OpenTelemetry — hands-on training for teams building distributed .NET systems.

    Web Development – Backend Corporate
    Live Course
    5 modules
    View
  • Microservices with Java, Spring Boot and Spring Cloud

    End-to-end microservices in the Java ecosystem with Spring Boot 3, Spring Cloud Gateway, OpenFeign/RestClient, Resilience4j, Spring for Apache Kafka, Debezium/Outbox, Micrometer Tracing and Testcontainers.

    Web Development – Backend Corporate
    Live Course
    5 modules
    View
  • API Development with GraphQL

    Schema-first and code-first GraphQL design, queries/mutations/subscriptions, solving N+1 with DataLoader, authorisation, query complexity limits and Apollo Federation — for teams building a flexible client-server data layer.

    Web Development – Backend Corporate
    Live Course
    5 modules
    View
  • Software Modelling with Domain-Driven Design (DDD)

    Ubiquitous language, Event Storming, Subdomain and Bounded Context mapping, and Aggregate/Entity/Value Object/Domain Event tactical patterns — for engineering and architecture teams modelling complex business domains.

    Web Development – Backend Corporate
    Live Course
    5 modules
    View
  • Inter-Service Communication with gRPC and Protocol Buffers

    Protocol Buffers (proto3) schema design, HTTP/2 unary and streaming RPC models, schema governance with Buf, deadline/cancellation propagation, load balancing and mTLS security — for teams building low-latency inter-service communication.

    Web Development – Backend Corporate
    Live Course
    5 modules
    View

Get in touch