Renewed Course ! Design Microservices Architecture with Patterns & Principles

I have just FULLY RENEWED WITH HIGH QUALITY CONTENT of my course — Design Microservices Architecture with Patterns & Principles

In this course, we’re going to learn how to Design Microservices Architecture with using Design Patterns, Principles and the Best Practices with Iterate Design Architecture from Monolithic to Microservices. We will using the right architecture design patterns and techniques.

I’ve re-recorded the entire course with high quality content including all Microservices Patterns like API Gateway, BFF, CQRS, Event Sourcing, SAGA, Outbox, CDC, Sidecar, Service Mesh, Retry, Circuit Breaker Patterns.

Through 303 lectures and 17 hours worth of HD-quality content, you’re going to journey through some of the deepest depths of the Microservices Architecture Patterns & Principles.

I am offering a LIMITED BEST PRICE OFF DISCOUNT FOR YOU at the launch. This offer EXPIRES IN 5 DAYS.


Course Details

This course is will be the journey of software architecture design with step by step evolving architecture monolithic to event driven microservices.

We will start the basics of software architecture with designing e-commerce Monolithic architecture that handles low amount of requests.

After that step by step evolves the architecture with

  • Layered Architecture
  • Clean Architecture
  • Modular Monolithic Architecture
  • Microservices
  • Event-Driven Microservices Architectures
  • and lastly Serverless Microservices Architectures

with designing together that handle millions of requests. A step-by-step process for software system design and evolve from monolithic to microservices following the patterns & principles.

Architecture Design — Vertical Considerations

We will discuss microservices architectures with all aspects,

  • Microservices Decomposition
  • Microservices Communications (Sync / Async Message-Based Communication, API Gateways)
  • Microservices Data Management (Databases / Query / Commands)
  • Microservices Transaction Management
  • Microservices Distributed Caching
  • Microservices Deployments with Containers and Orchestrators
  • Microservices Resilience

with applying microservices design patterns and practices. We are going to design with together and step by step with refactor architectures with above aspects of microservices pillars.

We will start with designing Monolithic Architecture. And you can see that we have Functional and Non-functional requirements that should cover our design and we have patterns and principles toolbox that we will learn and use these principles when evolving architectures.

Way of Learning — The Course Flow

We will always starts with the problem and try to solve this problem with learning and designing new architectures, patterns and best practices.

We will complete this circle for every section of the course. You will find that we will add new requirements in order to handle millions of request and learn new patterns and practices that will use these principles when evolving architectures.

We will see full of patterns and principle toolbox is loading with new patterns and apply them into current designs. We will see latest patterns that we use more than 30 patterns and practices with implementing High scalability, High availability and handle millions of request requirements.

Let me write some microservices pattern which we covered in this courses;

  • The Database-per-Service Pattern
  • API Gateway Pattern, Gateway Routing/Aggregation/Offloading Pattern
  • Backends for Frontends pattern BFF
  • Service Aggregator Pattern, Service Registry/Discovery Pattern
  • Fan-out Publish/Subscribe Messaging Pattern
  • Topic-Queue Chaining & Load Balancing Pattern
  • The Shared Database Anti-Pattern and Polyglot Persistence
  • Database Sharding Pattern, CAP Theorem
  • Materialized View Pattern
  • CQRS and Event Sourcing Patterns
  • SAGA Pattern Choreography-based/Orchestration-based SAGA
  • Compensating Transaction Pattern
  • Transactional Outbox Pattern
  • Dual Write Problem
  • CDC — Change Data Capture with Outbox Pattern
  • Event Hubs and Real-time Event Streaming in Event-Driven Microservices Architecture
  • Cache-Aside Pattern for Microservices Distributed Caching
  • Sidecar Pattern
  • Service Mesh Pattern
  • DevOps and CI/CD Pipelines for Microservices Deployments
  • Deployment Strategies for Microservices: Blue-green, Rolling and Canary deployments
  • Infrastructure as Code (IaC) and usage in Microservices Deployments
  • Microservices Resilience, Observability and Monitoring Patterns
  • Retry and Circuit Breaker Patterns
  • Bulkhead / Timeout / Cache / Fallback Patterns
  • Elastic Stack for Microservices Observability with Distributed Logging
  • Microservices Health Checks: Liveness, Readiness and Performance Checks
  • Serverless Microservices Architecture implementation on AWS

So the course flow will be the both theoretical and practical information;

  • We will always start with a business problem
  • After that we will learn a specific pattern, why and where we should use
  • After that we will see the Reference architectures that applied these patterns
  • After that we will design our architecture with applying this newly learned pattern with together
  • And lastly we will decide which Technologies can be choices for that architectures.

And at the last section, we will made Code Review for Existing Microservices Architecture Repository on GitHub for practical implementation of microservices architecture.

So this course will includes

  • Hands-on Design Activities
  • Iterate Design Architecture from On-Premises to Cloud Serverless architectures
  • Evolves architecture monolithic to Event-Driven Microservices Architectures
  • Refactoring System Design for handling million of requests
  • Apply best practices with microservices design patterns and principles
  • Examine microservices patterns with all aspects like Communications, Data Management, Caching and Deployments
  • Prepare for Software Architecture Interviews
  • Prepare for System Design Architecture Interview exams.

I have been joined several famous company’s architecture position interviews, also involved software architect positions assessment process more than 50+ interviews collect the architecture requirements for software industry positions.

So with this course, you will gain real-world experience about all architecture positions from monolithic to event-driven microservices architectures.

This course prepared for the beginner but at least you should familiar with basics of software architectures. This course will have good theoretical information but also will be 90% of hands-on design activities. All course architecture steps will designed step by step and together.

Architecture Design Journey Diagrams

We will start with designing Monolithic Architecture:

After that we will evolve architecture with learning new Architectures and Patterns. We write-down functional and non-functional requirements that should cover our design and we have patterns and principles box that we will learn and use these principles when evolving architectures.

With this learnings, we have designed Modular Monolithic Architecture:

After that continue to learn new architectures and pattern to evolve our architecture and design Microservices Architecture. Patterns: The Database-per-Service Pattern, Polygot Persistence

Evolve microservices architecture with solving communication problems. Microservices Communications: HTTP Based RESTful API, GraphQL API, gRPC API.

Continue with Microservices Sync Communications: API Gateway Pattern, Backends for Frontends Pattern-BFF.

Microservices Async Communications: Single-receiver Message-based Communication (one-to-one model), Multiple-receiver Message-based Communication (one-to-many model-topic), Fan-Out Publish/Subscribe Messaging Pattern, Topic-Queue Chaining & Load Balancing Pattern:

Microservices Data Management Patterns: Materialized View Pattern, CQRS Design Pattern, Event Sourcing Pattern, Eventual Consistency Principle.

Microservices Distributed Transactions: SAGA Pattern, Choreography and Orchestration-based SAGA, Compensating Transaction Pattern, Dual-Write Problem, Transactional Outbox Pattern, CDC — Change Data Capture.

Microservices EDA: Asynchronous, Decoupled communication, Event Hubs, Stream-Processing, Real-time processing. High volume events

Microservices Deployment: Docker and Kubernetes Architecture, Helm Charts, Kubernetes Patterns; Sidecar Patterns, Service Mesh Pattern
DevOps and CI/CD Pipelines, Deployment Strategies; Blue-green, Rolling, Canary and A/B Deployment, Infrastructure as code (IaC).

Microservices Resilience Patterns: Retry, Circuit-Breaker, Bulkhead, Timeout, Fallback Pattern, Distributed Logging and Distributed Tracing, Elastic Stack; Elasticsearch + Logstash + Kibana, OpenTelemetry using Zipkin, Kubernetes Health Monitoring with tools like Prometheus and Grafana.

Serverless Microservices Architectures: AWS Lambda, Amazon DynamoDB, Amazon EventBridge, Amazon SQS, Amazon API Gateway.

Also, we are going to examine some real-world github repositories and make code review of e-commerce application which is implemented on Different Architectures with using different technologies. See example microservices repository in here:

DEMO: Code review of Microservices Architecture .NET Implementation:

I hope you’ll join me on this journey and develop this project with me. You can use discounted link below:



Design microservice systems using the right architecture design patterns and techniques. Handle millions of request with designing system for high availability, high scalability, low latency, and resilience to network failures on microservices distributed architectures.

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store
Mehmet Ozkaya

Software Architect | Udemy Instructor | AWS Community Builder | Cloud-Native and Serverless Event-driven Microservices