Who Should Take This Course?

The Course at a Glance

Introduction

The Problem: Legacy Systems

The Strangler Pattern: A Solution

The Architecture of the Strangler Pattern

Strangler Pattern: A Detailed  Example

Key Insights and Implications

Strangler Fig Pattern

Introduction to the API Gateway Pattern

Advantages of API Gateway Pattern

API Gateway Pattern: An Example

Performance Implications

System Design Example

API Gateway Pattern

Introduction to BFF

The Problem: Traditional Backend Models

The Architecture of the BFF Pattern

BFF Pattern: An Example

System Design Examples

Backends for Frontends (BFF) Pattern

What is Service Discovery Pattern?

The Problem: Service Coordination in Distributed Systems

Service Discovery Pattern: A Solution

The Architecture of the Service Discovery Pattern

The Inner Workings of the Service Discovery Pattern

Service Discovery Pattern: An Example

Performance Implications and Special Considerations

Service Discovery Pattern

The Problem: The Struggles of Distributed Systems and Service Failures

The Circuit Breaker Pattern: An Effective Shield Against Cascading Failures

Circuit Breaker Pattern: An Example

Circuit Breaker Pattern

The Problem: Failure Propagation in Distributed Systems

The Bulkhead Pattern: A Solution

The Architecture

The Inner Workings

Bulkhead Pattern: A Example

Conclusion

Bulkhead Pattern

The Problem: Unreliable External Resources in Distributed Systems

The Retry Pattern: A Solution

The Architecture of the Retry Pattern

The Inner Workings of the Retry Pattern

Retry Pattern: An Example

Use Cases and System Design Examples

Retry Pattern

Introduction to the Sidecar Pattern

The Problem: Monolithic Application Management

A Solution to the Monolithic Mayhem

The Architecture of the Sidecar Pattern

Sidecar Pattern: Bringing Theory to Practice with an Example

System Design Examples: Bringing the Sidecar Pattern to Life

Sidecar Pattern

Introduction to Saga Pattern

The Problem: Traditional Transaction Models

The Saga Pattern: A Solution

The Architecture of the Saga Pattern

The Inner Workings of the Saga Pattern

Saga Pattern: A Example

Saga Pattern

The Problem: Managing Complex Interactions in Distributed Systems

Event-Driven Architecture: A Promising Solution

The Architecture of the Event-Driven Architecture Pattern

The Inner Workings of the Event-Driven Architecture Pattern

Event-Driven Architecture Pattern: An Example

Event-Driven Architecture Pattern

The Problem: Traditional CRUD Operations

CQRS Pattern: A Solution

The Architecture of the CQRS Pattern

The Inner Workings of the CQRS Pattern

CQRS Pattern: An Example

Issues, Special Considerations, and Performance Implications

CQRS (Command Query Responsibility Segregation)

The Problem: Configuration Management in a Microservices Architecture

The Solution: Configuration Externalization Pattern

Unveiling the Architecture: How Does Configuration Externalization Work?

Delving into Code: An Example

Considerations and Implications

Use Cases and Real-world Examples

Configuration Externalization Pattern

Embrace the Future of Software Architecture

Course Wrap-up

Grokking Microservices Design Patterns

Command Query Responsibility Segregation (CQRS) is a design pattern in software architecture that helps solve the kind of problem we just discussed. To understand it better, let's break down the term:

- **Command**: This refers to an instruction to do something, like creating, updating, or deleting data (i.e., CUD operations). In our banking example, a command would be processing a deposit or a withdrawal.
- **Query**: This is a request to retrieve data without changing it. Checking your account balance in the banking app is a query.