Design Microservices Architecture with Patterns & Principles

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

By the end of the course, you will learn how to handle millions of requests by designing a system for high availability, high scalability, low latency, and resilience to network failures on microservices distributed architectures.

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

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

After that step by step, the architecture will;

• Layered Architecture

• Clean Architecture

• Modular Monolithic Architecture

• Microservices

• Event-Driven Microservices Architectures

• lastly Serverless Microservices Architectures with designed together that handle millions of requests. This is a step-by-step process for software system design and evolves from monolithic to microservices following the patterns & principles.

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 together and step by step with refactoring architectures with all aspects of microservices pillars.

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

Way of Learning — The Course Flow

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

• Problem -> Learn -> Design -> Adapt -> Evaluate

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 requests and learn new patterns and practices that will use these principles when evolving architectures.

You will find that we will add new requirements in order to handle millions of requests and learn new patterns and practices that will use these principles when evolving architectures.

We will see full of patterns and the principle toolbox is loading with new patterns and applying them to current designs. We will see the latest patterns that we use more than 30 patterns and practices with implementing high scalability, high availability and handling millions of request requirements.

Let me write some microservices patterns that we covered in this course;

• 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 both theoretical and practical information;

• We will always start with a business problem

• 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 by applying this newly learned pattern together

• And lastly, we will decide which Technologies can be choices for that architecture.

In the last section, we will make a Code Review for Existing Microservices Architecture Repository on GitHub for practical implementation of microservices architecture.

So this course will include

• Hands-on Design Activities

• Iterate Design Architecture from On-Premises to Cloud Server-less architectures

• Evolves architecture monolithic to Event-Driven Microservices Architectures

• Refactoring System Design for handling millions 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 joined several famous company's architecture position interviews, also been involved software architect position assessment process with more than 50+ interviews collecting the architecture requirements for software industry positions.

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

This course is prepared for the beginner but at least you should be familiar with the 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.

I hope you'll join me on this journey and develop this project with me.