BIG NEWS! Design Microservices is Now Fully Updated

This isn’t just a refresh; it’s a brand new, hands-on experience designed to turn architectural theory into practical, real-world skill. If you’re a software developer, architect, or tech lead, this is for you.

CQRS and Event Sourcing for EShop Architecture

Get Udemy Course with limited discounted coupon —Design Microservices with Patterns & Best Practices

Design Architecture Journey

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

This course is a step-by-step journey where we evolve an application from a simple monolith to a complex, resilient, cloud-native system. Here’s a glimpse of the path we’ll take:

1. The Monolith (The Foundation): We start by designing and exploring the code for a classic Monolithic E-Shop. We see its initial simplicity and quickly identify the scaling and deployment pains that drive the need for change.
2. Structuring for Growth (3-Tier & Modular Monolith): We refactor our monolith, first into a 3-Tier architecture to separate the UI, and then into a Modular Monolith to create clear internal boundaries. You’ll see how this improves code organization and team autonomy even before moving to microservices.
3. Making the Leap to Microservices: We perform our first decomposition, applying patterns like Decompose by Business Capability and Domain-Driven Design (DDD) principles to create our initial set of microservices (Catalog, Basket, Ordering), each with its own database (Database-per-Service).
4. Mastering Distributed Communication: With separate services, we tackle communication. We design and explore code for:

• RESTful APIs, GraphQL, and high-performance internal gRPC calls.
• API Gateways (using YARP) to create a managed entry point.
• The Backend for Frontends (BFF) pattern to tailor APIs for different clients.

5. Building Resilient, Event-Driven Systems: We solve the challenges of synchronous call chains by embracing asynchronous communication. You’ll design and see code for:

• Event-Driven Architecture with RabbitMQ as our message broker.
• Distributed Transactions using the Saga pattern.
• Solving the Dual Write problem with the Transactional Outbox pattern and Change Data Capture (CDC).

6. Designing for Production Reality: Finally, we make our system production-ready by learning and applying:

• Containers (Docker) and Orchestration (Kubernetes).
• Zero-Downtime Deployment Strategies (Blue-Green, Canary).
• Infrastructure as Code (IaC) and GitOps workflows.
• Resilience Patterns (Retry, Circuit Breaker) and full-stack Observability (Logging, Tracing, Metrics) with Aspire’s built-in tools.

Architecture Design — Vertical Considerations

As we evolve our E-Shop, We will discuss microservices architectures with all aspects, that we call these aspects as a vertical considerations.

• Microservices Decomposition — and we’ll learn decomposition patterns and apply when decompose our EShop monolith app into smaller services
• Microservices Communications, (Sync / Async Message-Based Communication, API Gws) both synchronous like REST and gRPC, and asynchronous message-based communication using tools like RabbitMQ, complete with API Gateways.
• Data Management is huge in microservices. (Databases / Query / Commands ) We’ll implement patterns like Database-per-Service, explore Polyglot Persistence, and even get into CQRS and Event Sourcing
• Distributed Transactions using the SAGA pattern
• Distributed Caching strategies and implement them in our services.
• Deployments using Containers like Docker and orchestrators like Kubernetes, and we’ll Dockerize our .NET microservices.
• And crucially, Resilience. We’ll code patterns like Retry and Circuit Breaker to make our system robust.

Essentially, for every pillar of microservices, we’ll be refactoring our E-Shop architecture, applying these patterns, and you’ll see the direct impact in the codebase.

Get Udemy Course with limited discounted coupon — Design Microservices with Patterns & Best Practices

Way of Learning — The Course Flow

Here you can see the Course Flow that we will follow during the course when learning and designing new architectures.

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

That means you’re not just passively receiving information. You’re actively participating in the architectural decision-making process, seeing the direct impact of each pattern and principle through code.

We’ll emphasize the ‘why’ behind every decision, ensuring you build a deep understanding. We will complete this circle for every section of the course.

Now lets see some examples of what we will learn and design step by step.

What “Hands-On Code” Really Means

When I say hands-on, I mean it. For each architectural stage, there is a dedicated, runnable GitHub repository. In every “Code Exploration” lecture, we will:

• Examine the Code: Understand the project structure and key implementation details.
• Run the Full Application: See all the services and backing stores (PostgreSQL, Redis, RabbitMQ, SQL Server) come to life with a single command using .NET Aspire.
• Explore the Dashboards: Use the Aspire dashboard, Grafana, and RabbitMQ Management UI to see what’s happening.
• Test End-to-End: Perform real use cases like adding items to a cart and checking out.
• Observe the System: Dive into structured logs, distributed traces, and performance metrics to validate our design and understand its behavior.

Codes of Microservices Architecture .NET Implementation https://github.com/mehmetozkaya/Design-Microservices-Architecture-with-Patterns-Principles

A Special Invitation to You

This course is for every developer who wants to become an architect, and for every architect who wants to ground their theoretical knowledge in practical, modern implementation. It’s the course I wish I had when I was making this journey.

To celebrate the launch of this massive update, I’m offering a special discount to the Medium community.

For the next 5 days only, you can enroll in the brand new “Design Microservices Architecture with Patterns & Principles” for the best possible price.

Get Udemy Course with limited discounted coupon — Design Microservices with Patterns & Best Practices

Thank you for reading, and I hope to see you on this architectural journey with me. Let’s stop just drawing boxes and start building truly robust, scalable systems together.