How override-dev/modularmonolith works
Project type and purpose
• This repository provides two ASP.NET Core “project templates” for building modular monolith web-API applications with Clean Architecture.
• One template scaffolds a “Host” (the main monolith web API + cross-cutting library). The other scaffolds a “Module” (plug-in sub-application) with its own Domain, Contracts, Application, Infrastructure, and Endpoints layers.
File structure
Top-level folders:
• “Monolith” – contains the Host template:
• Server.CrossCuttingConcerns (shared library for IModuleInstaller, DI, common services)
• Server (ASP.NET Core Web API project)
• “Module” – contains the Module template:
• Server.ModuleX.Contracts (DTOs, Queries)
• Server.ModuleX.Domain (Entities)
• Server.ModuleX.Application (MediatR queries/handlers, validators)
• Server.ModuleX.Infrastructure (Integrations, data handlers)
• Server.ModuleX.EndPoints (FastEndpoints HTTP endpoints)
• Server.ModuleX.Module (ModuleInstaller wiring up DI for the module)
• .template.config folders – Templating metadata (template.json)
README for additional insights
• Clean Architecture + Modular Monolith
• Uses ASP.NET Core, FastEndpoints (HTTP layer), MediatR (in-process mediator), FluentValidation (validators), Ardalis.Result (result pattern)
• Modules plug into the Host via IModuleInstaller and ServiceExtensions
• Swagger UI for testing endpoints
a. Main components:
• Client / Swagger UI (HTTP consumer)
• ASP.NET Core Host (Server)
• CrossCuttingConcerns Library
• Module(s) (one or more):
• EndPoints layer
• Application layer (MediatR)
• Domain layer (Entities, business rules)
• Infrastructure layer (data access, external integrations)
• Persistence (database) or external systems
b. Relationships and interactions:
• Client → HTTP EndPoints (FastEndpoints)
• EndPoints → Application (invokes MediatR requests/queries)
• Application → Domain (business logic, entities)
• Application → Infrastructure (data access, handlers)
• Infrastructure ↔ Database / External API
• Host (Startup/Program) uses CrossCuttingConcerns + ModuleInstaller to register each module’s ServiceExtensions
c. Architectural patterns/design principles:
• Modular Monolith: separates features into independently deployable modules plugged into one runtime
• Clean Architecture / Onion: clear layer boundaries (UI → Application → Domain → Infrastructure)
• CQRS / Mediator pattern: queries and commands via MediatR
• Dependency Injection: each layer exposed via DI
• Template-based extensibility: modules added via IModuleInstaller interface
d. Key technologies/frameworks:
• ASP.NET Core (Host)
• FastEndpoints (HTTP Endpoint definitions)
• MediatR (in-process messaging)
• FluentValidation (validators in Application layer)
• Ardalis.Result (Result pattern for return types)
Elements
• Clear component labels (Host, CrossCuttingConcerns, ModuleX.EndPoints, ModuleX.Application, etc.)
• Blue rectangles for code projects (Host, Modules)
• Green rectangles for layers within a module
Detailed capture of essential elements
• On the Host boundary, show CrossCuttingConcerns as a shared utility library that all Modules and the Host reference
• ModuleInstaller point in Host.Startup or Program.cs where modules register their layers