How to handle database migrations in a modular monolith with DDD?

The project uses separate database schemas per module, and migrations are managed independently for each module, typically via tools like Entity Framework Core. Check the Infrastructure layer examples for module-specific migration strategies.

Modular monolith vs microservices: which should I choose?

This project advocates for modular monoliths when deployment simplicity and reduced operational overhead are priorities, while maintaining encapsulation. Opt for microservices only if you need independent scaling, deployment, or technology stacks per module.

What are best practices for testing domain models in DDD?

Focus on testing the public API of aggregates without mocking internal states, use SUT factories to prepare test data, and avoid overspecification by not relying on internals, as demonstrated in the unit tests section.

How to implement event sourcing in .NET like in this project?

The Payments module uses SQL Stream Store for event sourcing, with examples on persisting events, projecting read models, and handling commands, emphasizing eventual consistency and stream-based patterns.

Can I use this for real-time applications?

Not directly, as the core architecture is async event-driven. Real-time features would require augmenting with technologies like WebSockets or SignalR for immediate communication, outside the standard module integration.

How to secure APIs with JWT and RBAC in this setup?

It implements JWT authentication via IdentityServer and RBAC with fine-grained permissions checked at the controller level, using the User Access module for centralized authorization logic.

Open-Awesome

Modular Monolith

MITC#

A production-ready .NET modular monolith application implementing Domain-Driven Design, CQRS, and event-driven architecture.

GitHub

13.7k stars2.2k forks0 contributors

What is Modular Monolith?

Modular Monolith with DDD is a production-ready reference application built with .NET that demonstrates how to implement a modular monolith architecture using Domain-Driven Design principles. It solves the problem of building maintainable, large-scale backend systems by structuring the application into independent modules that communicate asynchronously, avoiding the complexity of microservices while preserving separation of concerns.

Target Audience

Backend developers and architects working with .NET who want to learn or implement Domain-Driven Design, modular monoliths, or event-driven architectures in real-world applications.

Value Proposition

Developers choose this project because it provides a complete, well-documented implementation beyond simple examples, showcasing best practices in testing, security, and asynchronous module integration that can be directly applied to production systems.

Overview

Full Modular Monolith application with Domain-Driven Design approach.

Use Cases

Best For

Learning Domain-Driven Design tactical patterns in .NET
Implementing a modular monolith as an alternative to microservices
Building event-driven systems with reliable asynchronous communication
Structuring large backend applications with clear bounded contexts
Applying CQRS with raw SQL queries and DDD command handlers
Reference for integration and system testing strategies in modular architectures

Not Ideal For

Projects requiring rapid prototyping or minimal architectural overhead, as the DDD and modular setup adds significant complexity
Teams not using .NET or unfamiliar with C# and ASP.NET Core, since the implementation is deeply tied to this ecosystem
Applications needing strong, immediate consistency across modules, because it relies on eventual consistency through asynchronous event processing
Small-scale CRUD applications where the full DDD and CQRS machinery would be overkill

Pros & Cons

Pros

Production-Ready Completeness

Goes beyond a proof-of-concept with full implementation including security, testing, and event-driven integration, making it directly applicable to real-world systems.

Modular Architecture Clarity

Enforces strict separation of concerns with independent modules per bounded context, each with its own data schema, easing future migration to microservices if needed.

DDD Tactical Implementation

Demonstrates DDD patterns like Aggregates and Value Objects with high encapsulation and rich behavior, providing a clear reference for domain modeling best practices.

Comprehensive Testing Strategies

Includes unit tests for domain logic, integration tests with real databases, and system integration tests for cross-module workflows, ensuring robustness and reliability.

Cons

High Initial Complexity

The architecture requires setting up multiple modules, separate data schemas, and an event bus, which increases onboarding time and maintenance effort compared to simpler monoliths.

Learning Curve for DDD Novices

Assumes familiarity with Domain-Driven Design, CQRS, and event-driven patterns, making it challenging for teams without prior experience in these areas.

Async-Only Module Communication

Modules communicate strictly asynchronously via events, which can introduce latency and complexity for use cases requiring synchronous, immediate responses between bounded contexts.

Frequently Asked Questions

Related Projects

eShopOnWeb

Sample ASP.NET Core 8.0 reference application, now community supported: https://github.com/NimblePros/eShopOnWeb

Stars10,669

Forks5,989

Last commit1 year ago

EquinoxProject

Web Application ASP.NET 9 using Clean Architecture, DDD, CQRS, Event Sourcing and a lot of good practices

Stars6,773

Forks1,650

Last commit1 month ago

Event Sourcing .NET

Examples and Tutorials of Event Sourcing in .NET

Stars3,671

Forks543

Last commit21 days ago

Sample .NET Core CQRS REST API

Sample .NET Core REST API CQRS implementation with raw SQL and DDD using Clean Architecture.

Stars3,055

Forks671

Last commit2 years ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub