Building Modular Monoliths with .NET 8

Packt via Coursera

Go to class Write review

Overview

Coursera Flash Sale

40% Off Coursera Plus for 3 Months!

Grab it

Updated in May 2025. This course now features Coursera Coach! A smarter way to learn with interactive, real-time conversations that help you test your knowledge, challenge assumptions, and deepen your understanding as you progress through the course. In this course, you will learn how to develop modular monoliths using .NET 8, a modern approach to building scalable, maintainable, and flexible applications. By the end, you'll be proficient in creating modular monoliths that offer the benefits of both traditional monolithic architectures and microservices, avoiding the pitfalls of both. You'll explore key concepts like vertical slice architecture, dependency injection, domain-driven design (DDD), and clean architecture while gaining practical experience in building modular components. The course begins with an overview of modular monoliths and their advantages over traditional monolithic architectures and microservices. You'll also get a deep dive into the limitations of traditional monoliths and the common issues with microservices architecture, such as technology lock-in and distributed monoliths. After building a solid foundational understanding, you will explore modular monoliths, particularly through the lens of real-world examples such as Shopify's architecture and Amazon's transition from microservices back to a monolithic structure. Moving forward, you will dive into creating a complete modular monolith solution, beginning with setting up project structures, establishing folder hierarchies, and organizing dependencies. You'll explore the various layers and modules of the application, ensuring that each module is developed with best practices for scalability and maintainability. Special attention is given to domain modeling using DDD, implementing CQRS, and structuring APIs to achieve separation of concerns while optimizing for modularity. This course is perfect for developers looking to transition from traditional monoliths to modular architectures or those seeking a robust understanding of .NET-based modular monoliths. No prior experience with .NET 8 is required, though a basic understanding of C# and software development principles will be helpful. Whether you're working on large-scale enterprise applications or smaller projects, this course provides the tools and techniques to design and implement a highly maintainable and scalable solution.

Syllabus

Introduction

In this module, we will introduce the key concepts of the bootcamp, setting the stage for the rest of the course. You’ll gain access to the necessary resources and learn how to run the final application. We’ll also discuss how to best approach the course, ensuring a smooth learning experience.

Monolithic Architecture - What's wrong with Traditional Monoliths?

In this module, we will explore traditional monolithic architectures and their inherent issues. You will learn about the "Big Ball of Mud" anti-pattern and technology lock-ins that hinder scalability and flexibility in monolithic systems.

Microservices Architectures - Why it is not fit for all projects?

In this module, we will dive into microservices architecture and discuss its benefits and limitations. You’ll explore why microservices might not always be the best choice for certain projects and learn from Amazon’s experience in re-architecting their system.

The Bridge: Modular Monolith Architectures - Gateway between Monolithic and MS

In this module, we will explore modular monolithic architecture, which serves as a bridge between monolithic and microservices architectures. You'll learn about the benefits of modularity, incremental migration strategies, and real-world examples like Shopify’s approach.

Create EShop Modular Monolith Project Solution Structure

In this section, we will walk you through setting up the solution structure for the eShop modular monolith project. You will learn to organize modules, configure dependencies, and set up a clean architecture for a scalable application.

Wire-up Dependencies Between Modules (DI Management of Modules)

This module focuses on managing dependencies between modules using Dependency Injection. You’ll learn to configure DI in ASP.NET and handle the HTTP request pipeline to ensure modules communicate efficiently and independently

First Module: Catalog Module with Vertical Slice Architecture and CQRS

In this section, we will dive into the development of the catalog module using Vertical Slice Architecture and CQRS. You’ll learn how to structure the catalog module and explore domain modeling, API development, and the CQRS pattern for data handling

Develop Shared Domain for Tactical DDD Abstraction (Entity, Aggregate, Events)

In this module, we will focus on developing the shared domain using tactical DDD patterns. You’ll learn how to create entities, aggregates, and domain events and leverage MediatR to handle domain events effectively.

Develop Catalog Domain with Product Domain Entity Models

This module will guide you through the creation of the product domain model for the catalog module. You will learn how to build rich domain models, implement domain events, and apply these patterns to effectively handle product-related business logic.

Data Management of Modular Monolith: Setup Postgres as a Main Database

In this module, we will set up PostgreSQL as the main database for our modular monolith project. You’ll explore data isolation techniques, set up Docker containers for a cloud-native database, and configure PostgreSQL within a Dockerized development environment.

Develop Shared and Catalog Data-Infrastructure with EF Core Code First

In this section, we will build the data infrastructure for the shared and catalog modules using EF Core’s Code-First approach. You’ll configure migrations, seed data, and leverage EF Core interceptors for auditing and event dispatching.