.NET 9 Microservices, Modular Monolith: DDD & Vertical Slice

Explore microservices architecture, where autonomous, decoupled, resilient, and independently scalable services handle one specific business function—and emphasize ownership, agility, and composable architecture across the system.

Microservices operate autonomously with independent data stores and isolated hosting, enabling resilience, scalability, rapid deployments, and team ownership across a composable system.

Explore the benefits of microservices, including independent deployment, scaling, and resilience, while addressing challenges like data consistency, cross-service workflows, and monitoring, testing, and operations.

Explore modular monolith architecture as a middle ground between monoliths and microservices. Build a single deployable unit with encapsulated modules, in-memory communication, and clear separation of concerns.

Compare modular monoliths and microservices, highlighting independence, deployment as a unit, in-process communication, and options for data isolation, shared stacks, and team ownership.

Demonstrates a modular monolith using services with file storage—GridFS, MinIO, and Azure Blob—balancing latency and security, and explains when to keep storage as a module or convert to a microservice.

Compare microservices and modular monoliths, explore their architecture, characteristics, and challenges, and show how modules and microservices can coexist, with a module transforming into a microservice when requirements shift.

Discover how article domains structure core workflows and supporting systems across submission, review, production, and public pages, and how domain driven design models shared entities across contexts.

Discover how domain driven design centers software on the domain, modeling with the article aggregate, entities, and value objects, plus domain events and rules like unique titles within a journal.

Discover how domain driven design uses bounded contexts, expressive domain models, and external and internal events to prioritize primary domains and drive meaningful features.

Explore domain driven design to structure microservices around bounded contexts and events. Learn how article workflow components publish and subscribe to the article accepted event to enable modular, business-aligned systems.

Explore modular clean architecture that splits infrastructure into reusable modules while keeping persistence local to the service, enabling direct application-layer access to persistence and lean abstractions.

Build the first real microservice, the submission service, to handle article creation, author collaboration, and file uploads before review. Map architecture and requirements to the four-stage article workflow.

Explore clean architecture in the submission service, aligning the api layer, application layer, domain, and persistence to form a vertical slice that uses mediator and validators to stay cohesive.

Create a four-project solution (API, application, domain, persistence) using vertical slice architecture, wire dependencies, add mediator and fluent validation, expose minimal APIs, dockerize, test with Swagger, and push to GitHub.

Set up a blank solution in visual studio, structure articles and articles/src, then scaffold a submission microservice with api, application, domain, and persistence projects ready for docker.

Implement a create article endpoint in a clean architecture, wiring api endpoints to the application layer with MediatR, validating input, and returning an id response at api/articles.

Define the article domain with an article aggregate and journal entity, applying ddd principles to encapsulate create article rules in a domain behavior and raise a domain event.

Choose the right NuGet versions to prevent install and build issues, align with dotnet nine, and manage dependencies across solution projects with transitive usage.

Configure the persistent layer with EF Core by adding a submission dbContext, entities article and journal, and repository wiring; implement entity configurations, key generation, and a one-to-many journal-article relationship.

Create a repositories folder, implement a generic base repository and iRepository, and connect them to a db context to support get by id, add, update, remove, and delete operations, find.

Implement the create article command handler by injecting the journal repository, locating the journal, using the journal aggregate to create the article, and persisting it to return the article ID.

Define user stories by translating business scenarios into article submission workflows. Create and manage articles, assign corresponding authors and co-authors, upload manuscripts and supplements, and submit for editorial review.

Design endpoints following arrest principles to map user stories to domain actions, including create article, assign author, upload files, and submit article in a vertical slice architecture.

Define and validate article creation, author management, asset handling, and access controls, with clear file metadata, size limits, and submission lifecycle rules.

Discover the submission service built with vertical slice architecture, clean architecture, and domain driven design, isolating features like submitting articles and uploading assets via gRPC to critical services.

Apply domain-driven design to article and asset aggregates, with value objects, enums, and domain events driving submission, stage history, and auditing.

Configure dependency injection across API, application, and persistence layers, register swagger with Swashbuckle, mediator, and validators, and set up DbContext, repositories, and migrations.

Create a notfound and http exception in a dedicated exceptions block, then add a repository extension find by id or throw async to enforce not found checks during article creation.

Model the person, article, and article author to assign the current user as corresponding author, with article actor base, contribution areas, and user role types.

Configure entity persistence in EF Core by implementing person and article actor configurations, including IDs, a composite key, user mapping, and inheritance discriminators for article actor and author.

Assign current user as article author by updating create article command with created on and created by id, then attach a domain behavior to set the author via the DbContext.

Implement the assign author feature end-to-end, creating the assign author endpoint, handler, and domain concepts, wiring article and order roles, validation, and authorization.

Implement the create and assign author feature in a .NET 9 microservices project, building the command, validator, and handler, and exposing endpoints for author creation and assignment.

Implement a minimal API upload manuscript endpoint with from form binding, disable anti-forgery, and return a download URL while validating the file and asset type via a manuscript file command.

Develop the asset and file domain by implementing asset and file value objects, asset name and file name, and asset type definitions with extension validation.

Configure asset and file entities with EF Core, use complex properties for asset name and file, define asset type as an enum, and establish article-asset relations with cascade delete.

Implement a MediatR-based upload manuscript command handler, managing asset types with a new asset type definition, enforcing max asset counts, and using article-driven asset creation in a modular monolith.

Explore the modular file storage design for upload manuscript workflows, implementing a MongoDB GridFS-based file service with contracts for upload, download, and delete, plus dependency injection configuration.

implement the upload manuscript file command by integrating the file storage module and mongodb gridfs, generating the storage path from the asset, and uploading the file asynchronously.

Review all endpoints for this microservice, recognize the MVP scope, and follow the dedicated postman testing section to run and test what you've built across modules.

Manage authentication and user access with JWTs, role-based control, and refresh tokens across services. Define REST and gRPC endpoints for creating users, logging in, resetting passwords, and updating profiles.

Describe the user service requirements: admin-created users with email confirmation and token-based password setup, password resets, login with JWTs and refresh tokens, internal gRPC user info, RBAC, and performance goals.

Architect the authentication and user service with vertical slice, clean architecture, and domain driven design to ensure a single source of truth for user data across services.

Centralize authentication with a login flow that issues JWT tokens containing user id, email, and role claims for SSO across services, then enforce access via authorization middleware on protected endpoints.

Explore the tactical domain design of an authentication service, modeling the user as the aggregate root with value objects, enums, and domain events, including roles and refresh tokens.

Summarizes authentication and user service endpoints, role-based access control, and login features, while applying clean architecture and vertical slice patterns to model the user aggregate and plan code implementation.

Explore a clean architecture for creating a user within a modular microservices setup, uniting api and application layers with fast endpoints, domain events, value objects, and ef core persistence.

Implement the create user command, endpoint, and validator with fast endpoints and fluent validation in a vertical slice ASP.NET Core project, enforcing admin role and validating email and user roles.

Explore building the user domain aggregate with DDD, wiring the user created domain event, and implementing value objects like honorific and professional profile to enforce business rules for user creation.

Configure the persistence layer with EF Core and SQL Server by creating user and role configurations, mapping properties, enums, and value objects in a dedicated identity DbContext.

Implement the create user command handler with ASP.NET Identity and FastEndpoints, using the user manager to prevent duplicates, and publishing a user created event to trigger email.

Implement the email service module in a modular monolith with a contracts project and SMTP mail kit implementation; configure options and register the SMTP service.

Implement domain event for user creation to send a confirmation email via the SMTP service, building an HTML template message with a reset link from the base URL.

Explore the login flow to generate a JWT with user roles, then use the token in headers to authenticate and authorize requests across microservices.

Implement a login command handler as a combined fast endpoints login endpoint with aspnet identity. Inject user and sign-in managers, validate credentials, retrieve roles, and generate jwt and refresh tokens.

Generate a secure JWT token in the login command handler by assembling user id, name, email, and roles into claims; configure issuer, audience, secret, five-minute lifetime, and refresh token support.

Learn to generate and persist a refresh token alongside jwt, modeling refresh tokens in the user aggregate and exposing a refresh endpoint, with domain driven design and single responsibility principle.

Refactor the login flow by moving token generation to a TokenFactory in the application layer, applying SRP and DDD, and wiring JWT and refresh token handling through dependency injection.

Investigate the journal workflow, from creating journals and sections to assigning editors and guiding author submissions, and explore the rest endpoints that power submission, review, and production.

Define functional requirements for journals and sections, including unique name and abbreviation, pagination, editor assignments with automatic creation, and enable notifications, gRPC endpoints, authentication, caching, and consistency.

Builds a vertical slice, clean architecture, and domain-driven journal service that defines where articles go and who edits them, exposed via RESTful and gRPC endpoints.

Journal service updates trigger a journal updated event on RabbitMQ, letting the submission service sync its data and achieve eventual consistency through asynchronous integration.

Validate editor assignments in real time by invoking a gRPC call from the submission service to the journal service, which acts as the single source of truth for editor assignments.

Explore the tactical domain model of the journal service. The journal aggregate is the entry point, using aggregates, entities, value objects, and domain events to enforce rules and ensure consistency.

Map journal service features to http endpoints to show editor and admin interactions, and discuss clean architecture, vertical slice patterns, and integration with submission service via gRPC and domain events.

Develop the create journal feature in the journal service using clean architecture, detailing the API, application, domain, and persistence layers, with fast endpoints, fluent validation, and domain-to-dto mapping.

Implement the create journal feature as the core aggregate in a four-layer architecture, validate input, enforce unique names and abbreviations, and fetch the chief editor via gRPC from authentication service.

Implement a create journal feature by building a command and fluent validator within a vertical slice architecture, merging api and application layers, and wiring a fast endpoints post endpoint.

Build the journals domain within a vertical slice architecture, defining journal, section, and editor aggregates; configure Redis-based persistence with Redisham, document storage, indexing, dbcontext, and a repository pattern.

Implement a create journal command handler that injects the journal repository, validates name and abbreviation, persists the journal, returns its id via fast endpoints, and publishes a journal created event.

Define gRPC contracts using protobuf-net by creating an articles gRPC contracts project and a person service proto, enabling cross-service access from journal to authentication.

Explore aggregate decomposition by splitting the user into person and user within the authentication API, implementing a person gRPC service under vertical slice architecture, and organizing domains with distinct aggregates.

Configure the person entity with EF Core and SQL Server in the authentication persistence layer, establish a 1-to-1 user-to-person relation, and implement a person repository to fetch by user id.

Refactor login to use the person repository instead of the user manager and implement an email address value object. Add getByEmail, configure email properties, and use not found guards.

Refactor the create user endpoint to handle new or existing persons using getByEmailAsync, create the person if needed, assign the user via person.assignUser, and run in a DbContext transaction.

Implements the GetPerson gRPC method by injecting a personal repository, using cancellation tokens, and guarding not found results. Maps person to person info with mapster and configures value objects.

Implement the create journal endpoint by calling the person gRPC service to fetch the chief editor details, build the editor, and persist it in the editor repository.

Explore the startup flow of a general microservice by configuring API options, dependency injection, and gRPC clients, with Redis persistence and app settings.

Implement a keyword-based full-text search for journals using Redis, RedisOM, and CQRS, with pagination and editor DTO mapping.

Implement the approve article feature by adding a minimal API endpoint, define approve article command and validator, and coordinate cross-service approval with journal and authentication services via Mediator.

Implement a MediatR approve article command handler in CQRS to fetch the article via the article repository, apply approve behavior with editor actor, and return IdResponse.

Create the editor on demand by calling the person gRPC service when missing, using a get-or-create factory and dependency injection.

Implement the journal gRPC contract IsEditorAssignedToJournal using protobuf-net in C#. Define proto-like requests with journalId and userId and a boolean response, decorating with ProtoContract and ProtoMember attributes.

Implement the journal gRPC service in the journals microservice, using get by id or throw async with a journal repository, and register the gRPC contracts for server and client.

Explore the review microservice flow from submission to production, outlining user stories, anonymous invitation tokens, post actions, and key http endpoints for articles and assets.

Outline functional requirements for inviting reviewers via links, gRPC authentication, and editor decisions, with role-based security enforcing editor invitations, reviewer uploads pdf/doc 10 MB, and author revisions, plus two-year storage.

Explore the review microservice built with vertical slice architecture, detailing self-contained features from api, Carter, to domain aggregates and event-driven persistence with EF Core, plus RabbitMQ and gRPC.

Explore the tactical design of the review service by modeling aggregates—article, asset, and review invitation—and their entities, value objects, and domain events that drive the article lifecycle.

We recap the review service features, endpoints, and editor, reviewer, author actions. We cover functional and non-functional requirements, architecture with clean architecture and vertical slice, and the tactical domain model.

Explore a clean architecture setup for a net 9 microservices modular monolith, detailing api, application, domain, and infrastructure layers with tdd, vertical slice, mediator, fluent validation, and mobster mapping.

Explore an event-driven cross-service workflow that approves an article in submission service and reconstructs it in the review service via a single integration event, creating journal, actors, and assets.

Build the review microservice with the same structure as submission: api, application, domain, and persistence. Prepare to handle the article acceptance integration event once submission defines it.

Define an aggregate entity with a domain event interface, manage events in a private collection, and raise them on save changes to enable downstream integration.

Implement the article approved domain event handler, transform it into an integration event, and publish via MassTransit with RabbitMQ to the review service.

Configure Mapster mappings for the approve article feature, including article and person hierarchies, and email value objects. Register the config in startup and set up Masstransit and RabbitMQ.

Define rabbitmq options, credentials, host and virtual host in appsettings, then register MassTransit with RabbitMQ in startup via dependency injection, using custom snakecase and service-suffix formatters.

Load the full article with assets, actors and their persons using EF Core and LINQ, map to a DTO, and publish the article approved for review event via MassTransit.

Consume the article approved event in the review microservice using mass transit and rabbitmq, convert the article DTO into a review domain aggregate, and move related files to review storage.

Create domain aggregates for the review microservice, including article and asset aggregates and their shared value objects, using a vertical slice architecture and ddd principles.

Port the article and asset configurations into the review persistence layer using EF Core and SQL Server, implement inheritance with type discriminators, and set up the review dbcontext and repositories.

Implement the article approved for review consumer with RabbitMQ and MassTransit, transforming the article DTO into the review article aggregate by creating or fetching journal, actors, and assets via repositories.

Implement a cross-microservice file transfer by configuring two file storages with a factory-driven file service, leveraging Mongo GridFS for submission and review.

Refactor file storage by introducing a file metadata object with storage path, file name, content type, file size, and file ID, and adapt Mongo GridFS to use it.

Transfer the file from submission to review microservice by creating the file through the asset using file metadata, and publish the integration event via RabbitMQ and MassTransit using Mongo GridFS.

Register api, application services for the review microservice via dependency injection, enabling memory cache, Carter endpoints, authentication, file storage, and gRPC, with app settings for JWT, SMTP, and RabbitMQ.

Implement the invite reviewer endpoint with Carter and fluent validation, coordinating the article invitation flow via mediator, generating a token and URL, and sending the invitation email.

Apply domain-driven design to implement the review invitation as an aggregate root, linking articles and editors, with token-based invitation, status, and expiration, configured in ef core.

Implement the invite reviewer command with MediatR, repositories, and domain behaviors to create article invitations, prevent duplicates, fetch reviewer data via gRPC, emit domain events, and email tokenized invitations.

Demonstrates the accept invitation flow in a clean architecture with a C4 dynamic sequence diagram, validating commands, loading article and invitation, resolving or creating the reviewer, and returning IDs.

Implement the accept invitation endpoint in the review API using vertical slice architecture. Define the accept invitation command and response, validate the token, and publish via mediator.

Implement an AcceptInvitation command handler using gRPC and repositories to fetch article and invitation, create or load a reviewer, and assign the reviewer via domain behaviors with domain events.

Implement a MediatR domain event handler in the accept invitation feature within the vertical slice architecture to send a confirmation email to the editor when a reviewer is assigned.

Explore the article hub as a central, up-to-date access point for all articles across submission, review, and production, with rich search, timeline, and direct navigation to the correct microservice.

Examine the article hub requirements, including authenticated access and updates to a PostgreSQL snapshot. See how rich GraphQL searches via Hasura enable secure editor access and fast performance.

Explore the article hub architecture as an internal portal with a vertical slice design, delivering fast read endpoints via Hasura GraphQL on PostgreSQL and updating from integration events.

Explore the article hub's tactical domain, where the article aggregate is the root, collects title, scope, journal stage, and lifecycle dates, and manages actor relationships via user role type enumeration.

Discover Article Hub as the portal for all articles, enabling search, views, and timelines, powered by GraphQL search and a read-only projection updated by integration events with eventual consistency.

Build an article hub that consumes article approved for review and article accepted for production from submission and review microservices to maintain an article snapshot via mass transit and DbContext.

Set up the article hub by scaffolding the api and libraries, and implement an article approved for review event consumer using Masstransit, blocks messaging, and article abstractions.

Define the article hub domain by building the article aggregate and related entities (journal, person, article actor) with article stage, navigation properties, and shared domain abstractions.

Implement persistence for article hub using EF Core with PostgreSQL, configure article, journal, person, and article actor entities, their relationships and composite keys, and set up the DbContext.

Implement a MassTransit article approval event consumer that maps the article data transfer object to an article aggregate, ensures or creates journal and authors, and saves changes via EF Core.

Implement an integration events building block for the article workflow, introducing article accepted for production and article published events with article DTOs.

Implement the article accepted for production flow by consuming the event with MassTransit in the review microservice, updating the article stage and syncing reviewers in the article hub.

Create a GraphQL search endpoint for articles, leveraging the vertical slice pattern, Hasura on PostgreSQL, and a GraphQL read store to return article DTOs with pagination.

Implement article search pagination in a .NET 9 microservice by adding a pagination object with limit and offset, default values, and a max limit, exposed via GraphQL and UI filters.

Orchestrate a microservice startup by wiring dependency injection across api, application, and persistence layers, configuring Hasura GraphQL, PostgreSQL, Carter endpoints, and caching, plus middleware and testing scaffolds.

Explore the tech foundations behind .NET 9 microservices by implementing Docker and Docker Compose, configuring EF Core migrations, and enabling middleware with error handling, logging, and JWT-based cross-service authentication.

Implement a global exception middleware in ASP.NET Core to centralize error handling, map exceptions to HTTP status codes, log details, and return consistent JSON responses, including validation errors when present.

Stamp the authenticated user id across http and grpc pipelines with middlewares, endpoint filters, interceptors, and preprocessors to ensure auditable, traceable actions in the domain.

Introduce an endpoint filter for minimal APIs to stamp auditable actions with the current user id, using a claims provider and http context provider, and wire it in program.cs.

Implement a mediator pipeline behavior to assign the user id from the claim provider and wire it into the application services.

Implement a global preprocessor for fast endpoints to set the created by user id on commands implementing IAuditableAction. Register it to run before validation in the journals API.

Implement a gRPC assign user ID interceptor in asp.net core, override the unary server handler to set the user ID on auditable requests, and register the interceptor in gRPC options.

Compare four ways to assign the user id in http and gRPC in dotnet—filters, mediator behavior, fast endpoints preprocessor, and grpc interceptor—and implement in the application layer.

Configure and run your .NET 9 microservices in Docker, using parameterized Dockerfiles and Docker Compose to connect databases, message brokers, and file storage with volumes for persistence.

Learn how to manage entity framework core migrations per microservice, using initial create, update database, and rollback, while tracking migrations in the migration history table for isolated schema changes.

Learn to implement a design-time DbContext factory for EF Core migrations, decoupling the API from persistence and using a dedicated appsettings.json connection string.

Move the token generation methods into an application layer token factory to fix single responsibility. Inject it into the login endpoint to generate JWT and refresh tokens.

Create a base repository with a generic entity and dbcontext, implementing get by id async, add, update, remove, and delete by id, plus a find method and save changes proxy.

Explore building a read-only cache repository to serve catalog-like data from memory, avoiding database hits, using an in-memory cache with a cacheable interface and type-safe generics.

Create a claim provider to extract user claims from the JWT, including the user id, name, and email, and implement an HttpContext provider with extension methods to read claims safely.

Configure and validate MongoDB Gridfs file storage options by binding the settings section, enabling fail-fast startup checks, and extending configuration with type-based section retrieval and connection string validation.

Implement an SMTP email service within a modular monolith. Define contracts and implementations using MailKit, with options for SMTP configuration and services registration.

Create an abstract entity configuration base in EF Core to centralize ID key setup and database generation, implement the domain IEntity interface, and apply overrides in journal and article configurations.

Create a base abstract enum entity with a generic enum type, exposing id and name stored as int and string, enabling type-safe enums persisted as integers across entities.

Consolidate NuGet package versions to fix conflicts. Open the solution's NuGet package manager, use the consolidate tab to install the latest version for projects with older versions.

Leverage global using to centralize namespaces across projects, group third party libraries like mediator and frame validation, and apply them to commands, command handlers, and internal building blocks or domains.

Create a not found http exception and a generic http exception, then add a find by id or throw async extension for repositories in EF Core to signal not found.

Develop a generic value object base class in the blocks domain to enable equality by implementing GetEqualityComponents, overriding Equals and GetHashCode, and providing == and != operators for comparing professional profile instances.

Create a public abstract string value object base class, implement toString, getHashCode, and IEquatable, add an implicit string cast, then derive asset name, email, and file name with private constructors.

Plug in mediator and fluent validation, create a validation behavior for the MediatR pipeline, execute validators, throw a validation exception, and rely on middleware to return a bad request.

Test microservices from the architecture diagram by authenticating to create users and roles, follow an article through submission, review, production, and inspect Article Hub, journals, databases, and the API gateway.

Run the application locally with docker compose in Visual Studio, seed master and test data, and debug containers via docker desktop, exploring swagger endpoints for authentication, journals, and submissions.

Import the Postman collection and the demo environment from the GitHub repository. Duplicate or create a new environment, adjust variables, and run requests using the selected environment.

Test the auth service by creating admin and user accounts, logging in to obtain JWT and refresh tokens, and handling password resets and activations across microservices.

Utilize Postman environments to manage environment-specific base urls and tokens, substitute variables in requests, and verify tokens with jwt decoding and secrets.

Test the submission microservice with postman by creating articles in journals, assigning authors, uploading manuscripts and assets, submitting for review, and validating events via RabbitMQ, SQL Server, and MongoDB.

Explore testing the review microservice by inviting reviewers, handling token-based invitations, and uploading review reports, while reviewing how assets and files are stored in SQL and GridFS.

Test the Article Hub by validating endpoints, Hasura-backed GraphQL searches, and integration events from submission and review, while exercising authentication and author, journal, and editor workflows.

Test and validate journals in a microservices architecture by seeding data. Trace domain events as integration events across submission, review, and article hub to demonstrate event driven design.