.NET 8 Backend Bootcamp: Modulith, VSA, DDD, CQRS and Outbox from Udemy

In this bootcamp, you'll learn how to build robust, scalable, and maintainable applications using cutting-edge technologies and architectural patterns.

We will develop;

Modular Monoliths (Modulith) Architecture
Vertical Slice Architecture (VSA)
Domain-Driven Design (DDD)
Command Query Responsibility Segregation (CQRS)
Outbox Pattern for Reliable Messaging

We start with the basics and progressively dive deeper into each topic. You'll get hands-on experience building a complete EShop Modular Monolith application, implementing features like CQRS and the Outbox pattern.

We'll follow CQRS (Command Query Responsibility Segregation) and Vertical Slice architectures for module development.
Modules will communicate over In-process method calls-public APIs and use RabbitMQ for event-driven communication.
We'll secure our APIs with Keycloak, using OpenID Connect and Bearer Tokens.
We'll implement the Outbox Pattern for reliable messaging between modules.

Along with this you’ll develop following modules and items:

Catalog module which;

Using Asp.Net Core Minimal APIs and latest features of .Net8 and C# 12
Develop Vertical Slice Architecture implementation with Feature folders
DevelopNET, it's a deep dive into the world of Modular Monoliths with Vertical-Slice Architecture, Domain-Driven Design (DDD), CQRS, and advanced architectural patterns for Backend Development.

What's inside

Learning objectives

Modular monoliths (modulith) architecture
Vertical slice architecture (vsa)
Domain-driven design (ddd)
Command query responsibility segregation (cqrs)
Outbox pattern for reliable messaging
Cqrs (command query responsibility segregation) and vertical slice architectures for module development
Communicate over in-process method calls-public apis and use rabbitmq for event-driven communication
Secure apis with keycloak, using openid connect and bearer tokens
Aspnet core minimal apis and latest features of .net8 and c# 12
Vertical slice architecture implementation with feature folders
Ddd, cqrs patterns using mediatr library w/ following best practices
Use domain events & integration events when updatepricechanged event
Use entity framework core code-first approach and migrations on postgresql database

Cross-cutting concerns including logging with serilog, validation with mediatr pipeline behaviors, exceptions, pagination
Using redis as a distributed cache over postgresql database
Develop proxy, decorator and cache-aside patterns
Sync communications between catalog and basket modules w/ in-process method calls (public apis)
Async communications between modules w/ rabbitmq & masstransit
Develop user identity module with keycloak authentication
Oauth2 + openid connect flows with keycloak
Outbox pattern for reliable messaging w/ basketcheckout use case
Publish basketcheckoutevent to rabbitmq via masstransit library, consume from ordering module
Migrating to microservices: eshop modules to microservices w/ stranger fig pattern
Show more
Show less

Modular monoliths (modulith) architecture
Vertical slice architecture (vsa)
Domain-driven design (ddd)
Command query responsibility segregation (cqrs)
Outbox pattern for reliable messaging
Cqrs (command query responsibility segregation) and vertical slice architectures for module development
Communicate over in-process method calls-public apis and use rabbitmq for event-driven communication
Secure apis with keycloak, using openid connect and bearer tokens
Aspnet core minimal apis and latest features of .net8 and c# 12
Vertical slice architecture implementation with feature folders
Ddd, cqrs patterns using mediatr library w/ following best practices
Use domain events & integration events when updatepricechanged event
Use entity framework core code-first approach and migrations on postgresql database
Cross-cutting concerns including logging with serilog, validation with mediatr pipeline behaviors, exceptions, pagination
Using redis as a distributed cache over postgresql database
Develop proxy, decorator and cache-aside patterns
Sync communications between catalog and basket modules w/ in-process method calls (public apis)
Async communications between modules w/ rabbitmq & masstransit
Develop user identity module with keycloak authentication
Oauth2 + openid connect flows with keycloak
Outbox pattern for reliable messaging w/ basketcheckout use case
Publish basketcheckoutevent to rabbitmq via masstransit library, consume from ordering module
Migrating to microservices: eshop modules to microservices w/ stranger fig pattern
Show more
Show less

Syllabus

Introduction

Prerequisites, Source Code and Course Slides

See Final Application (need identity configurations - its only showcase)

Project Code Structure

Traffic lights

Read about what's good

what should give you pause

and possible dealbreakers

Covers modular monolith architecture, which offers a middle ground between traditional monoliths and microservices, potentially simplifying development and deployment for some projects

Explores Domain-Driven Design (DDD) principles, which can lead to more maintainable and scalable applications by aligning software design with business domain concepts

Implements CQRS and the Outbox pattern, which are valuable for building resilient and scalable systems, especially when dealing with complex data interactions and distributed transactions

Uses .NET 8 and C# 12, providing learners with experience in the latest features and improvements of the .NET ecosystem, which is highly relevant for modern development practices

Employs RabbitMQ for event-driven communication, a popular message broker that enables asynchronous communication between modules, enhancing system responsiveness and fault tolerance

Secures APIs with Keycloak, using OpenID Connect and Bearer Tokens, which are industry-standard protocols for authentication and authorization, ensuring secure access to application resources

Reviews summary

.net 8 modern backend architecture bootcamp

According to learners, this course provides a deep dive into modern .NET backend architecture covering patterns like Modulith, VSA, DDD, and CQRS. The practical EShop project is a major positive, praised for helping solidify learning. Students appreciate that it uses the latest .NET 8 and C# 12 features, keeping the content highly relevant. While the instructor's explanations are clear and the overall sentiment is overwhelmingly positive, some learners noted the pacing can be fast at times, and setting up external dependencies such as Keycloak and RabbitMQ required extra effort or prior experience. This bootcamp is highly recommended, especially for experienced developers.

The course pace can be quick in places.

"Found the pacing a little fast in places, particularly when integrating external services like Keycloak and RabbitMQ."

"Requires pausing and re-watching sections."

"Good course if you're comfortable with a fast pace and figuring out some details yourself."

Best suited for experienced .NET developers.

"might be challenging for someone without some prior experience in backend development or .NET."

"Good course if you're comfortable with a fast pace and figuring out some details yourself."

"Highly recommend for experienced .NET devs looking to deepen their understanding of modern architecture."

"Might be better for those with some prior experience with these tools [Keycloak, RabbitMQ]."

Course uses the latest .NET 8 and C# 12.

"The use of .NET 8 and C# 12 latest features keeps it current."

"The focus on .NET 8 and C# 12 is a major plus."

"The course is very up-to-date with .NET 8."

Building a real-world project solidifies learning.

"The hands-on project building an EShop modular monolith solidifies the learning."

"Building the EShop project step-by-step was incredibly helpful."

"The EShop project is a great way to see everything come together."

"A practical, hands-on guide to building modern .NET backends... The EShop project is a great way to see everything come together."

Explains complex architectural patterns clearly.

"The instructor's explanations are crystal clear, and the way he breaks down complex topics like DDD, CQRS, and Vertical Slice Architecture is simply amazing."

"The deep dive into architectural patterns like Modulith, VSA, and DDD is exactly what I needed."

"Explains complex topics like DDD and Modulith architectures with clear, concise examples."

"The instructor provides a clear path to understanding complex topics like DDD, CQRS, and implementing them..."

Setup for external services could be smoother.

"Some parts felt a bit rushed, especially the Keycloak integration and RabbitMQ setup."

"Could benefit from a bit more detailed explanations or troubleshooting tips for these external dependencies."

"Had some issues getting them set up correctly initially."

"However, the setup and integration parts, specifically Keycloak and RabbitMQ, were less smooth and required external searching for some clarity."

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in .NET 8 Backend Bootcamp: Modulith, VSA, DDD, CQRS and Outbox with these activities:

Review Domain-Driven Design (DDD) Principles

Show steps

Solidify your understanding of DDD principles before diving into the course. This will help you grasp the architectural decisions and patterns used in the EShop Modular Monolith application.

Browse courses on Domain-Driven Design

Show steps

Read articles and blog posts about DDD fundamentals.
Watch introductory videos on DDD concepts.
Review examples of DDD implementations in .NET.

Brush Up on ASP.NET Core Minimal APIs

Show steps

Familiarize yourself with ASP.NET Core Minimal APIs. This will make it easier to understand the Catalog module's implementation and the latest features of .NET 8 and C# 12.

Browse courses on Minimal APIs

Show steps

Work through a tutorial on creating Minimal APIs.
Experiment with different endpoint configurations.
Practice handling different HTTP methods (GET, POST, PUT, DELETE).

Implement a Simple CQRS Pattern

Show steps

Gain hands-on experience with the CQRS pattern. This will reinforce your understanding of how commands and queries are separated in the application's architecture.

Show steps

Define a simple domain model (e.g., a product with name and price).
Create command and query handlers for basic operations (e.g., create product, get product).
Implement a mediator to route commands and queries to their respective handlers.

Four other activities

Expand to see all activities and additional details

Show all seven activities

Explore RabbitMQ Tutorials

Show steps

Deepen your knowledge of RabbitMQ and message queuing. This will help you understand the asynchronous communication between modules using RabbitMQ and MassTransit.

Show steps

Follow a tutorial on setting up RabbitMQ locally.
Work through examples of publishing and consuming messages.
Investigate different exchange types and routing strategies.

Read 'Domain-Driven Design: Tackling Complexity in the Heart of Software'

Show steps

Gain a deeper understanding of Domain-Driven Design principles. This book provides a comprehensive guide to tackling complexity in software development using DDD.

View Domain-Driven Design Reference: Definitions and... on Amazon

Show steps

Read the key chapters on strategic and tactical DDD.
Reflect on how DDD principles apply to the EShop application.

Read 'Building Microservices: Designing Fine-Grained Systems'

Show steps

Understand the context of microservices and how they relate to Modular Monoliths. This book provides a comprehensive guide to designing fine-grained systems.

View Building Microservices: Designing Fine-Grained... on Amazon

Show steps

Read the chapters on decomposition strategies and integration patterns.
Compare and contrast microservices with Modular Monoliths.

Contribute to an Open-Source .NET Project

Show steps

Apply your .NET skills in a real-world project. This will help you solidify your understanding of the concepts covered in the course and learn from experienced developers.

Show steps

Find a .NET open-source project on GitHub.
Identify a bug or feature to work on.
Submit a pull request with your changes.

Career center

Learners who complete .NET 8 Backend Bootcamp: Modulith, VSA, DDD, CQRS and Outbox will develop knowledge and skills that may be useful to these careers:

Backend Developer

Backend developers build the server side of applications, and this course may be helpful in that pursuit. The practical skills gained in this course directly apply to back end development, focusing on technologies to build modular and scalable applications. A backend developer needs to understand how to design systems with clear module communications, and this course provides practice building systems with both In-process method calls and event-driven communication using RabbitMQ. Further, learning how to secure APIs, and implement reliable messaging patterns are necessary for backend development. The work a backend developer does has many overlapping skills with this course.

See salaries and explore the career path for Backend Developer

Software Engineer

Software engineers develop software, and this course may be useful in that pursuit. This course directly addresses many areas relevant to software engineering, such as architectural patterns, domain driven design, and command query responsibility segregation. A software engineer often needs to design and implement modular applications, which this course covers in detail using Modular Monoliths and Vertical Slice Architecture. Additionally, the course focuses on practical implementation, and may help a software engineer implement complex systems. The practical skills, especially relating to architecture, are a good fit for the work done by a software engineer.

See salaries and explore the career path for Software Engineer

Software Architect

A software architect designs the structure of software systems, and this course helps build a foundation for that. The course focuses on architectural patterns like Modular Monoliths and Vertical Slice Architecture, crucial for architects who need to design scalable and maintainable systems. By learning Domain-Driven Design and Command Query Responsibility Segregation, future architects may be better equipped to make informed decisions about software design. The hands-on experience with building a complete application may provide real-world context for the theoretical concepts of a software architect.

See salaries and explore the career path for Software Architect

API Developer

API developers design and implement application programming interfaces, and this course provides practical and relevant experience. The course teaches how to secure APIs using Keycloak, and how to implement communication between modules via public APIs. An API developer needs to understand how to build robust interfaces, and this course helps you do just that. The course's emphasis on .NET 8 and C# 12 may also be useful to an API developer looking to expand their skills set. An API developer should consider the course as it has many common learning objectives.

See salaries and explore the career path for API Developer

Application Developer

Application developers build software applications and this course may be useful in that pursuit. Gaining expertise in architectural patterns such as Modular Monoliths and Vertical Slice Architecture directly applies to an application developer's daily work. The course will help an application developer build applications with clear module communications, and it introduces event driven communication as well. An application developer also requires skills in securing APIs and implementing reliable messaging patterns, which the course directly addresses. The practical skills an application developer needs are present in the scope of this course.

See salaries and explore the career path for Application Developer

System Designer

System designers create the architecture of systems, and this course helps build a foundation in that pursuit. The course focuses on architectural patterns, which are important to system designers. Learning about Modular Monoliths and Vertical Slice Architecture allows designers to build maintainable and scalable systems. The course also covers Domain-Driven Design, which may help designers better model complex systems. A system designer needs to make choices based on sound principles, and the course emphasizes best practices relating to system design. A system designer does work that overlaps with the lessons of this course.

See salaries and explore the career path for System Designer

Solutions Architect

Solutions architects design solutions to specific business problems, and this course helps provide a foundation. Understanding concepts like Modular Monoliths and Vertical Slice Architecture enables a solutions architect to create more effective solutions. The course's focus on Domain-Driven Design may help structure solutions that align with business needs. A solutions architect should be skilled in both high level design, and the details of implementation; this course's hands-on approach may provide practical skills, helping in such a pursuit. The work a solutions architect does has overlap with this course's stated learning objectives.

See salaries and explore the career path for Solutions Architect

Full-Stack Developer

Full stack developers work on both the front and back end of applications, and this course may be useful for backend development in such a role. While this course does not cover front end development, the back end expertise is critical for full stack development. A full stack developer may utilize the lessons of the course to build robust and scalable applications, implementing architectural patterns, and managing module communications. A full stack developer is required to understand how to secure APIs and implement reliable messaging patterns, which are touched on in this course. The work a full stack developer does has many overlapping skills with the course.

See salaries and explore the career path for Full-Stack Developer

Technical Lead

Technical leads guide development teams, and this course may help them do so. A technical lead needs to understand architectural patterns and be able to make informed decisions regarding software design, and this course touches on this with Modular Monoliths, Vertical Slice Architecture, and Domain Driven Design. The course may provide a technical lead with a deeper understanding of implementation by providing direct practical experience. A technical lead should consider the course to better understand the technological choices being made. The work of technical leads is very broad, and this course's focus on architecture may be helpful.

See salaries and explore the career path for Technical Lead

Development Team Lead

Development team leads manage development teams, and this course helps in that pursuit. Understanding architectural patterns, such as Modular Monoliths, Vertical Slice Architecture, and Domain Driven Design allows a development lead to better oversee projects. This course provides practical experience which may help a lead understand the technical challenges that developers face. A development team lead also needs to understand the best practices covered in the course, such as module communication and securing APIs. This course may be useful for a development team lead seeking to improve their ability to manage teams.

See salaries and explore the career path for Development Team Lead

Enterprise Architect

Enterprise architects design the high-level structure of an organization's technology systems, and this course helps develop relevant skills for such a role. Enterprise architects benefit from understanding architectural patterns, such as Modular Monoliths and Vertical Slice Architecture, both of which are covered in the course. Enterprise architects also need to make informed decisions about system design, and the practice gained from this course in Domain Driven Design may prove helpful. An enterprise architect needs a broad range of skills and this course helps provide a valuable piece of the puzzle. The theoretical focus of this course as well as the practical experience makes it relevant to an enterprise architect.

See salaries and explore the career path for Enterprise Architect

Integration Engineer

Integration engineers are responsible for integrating systems, and this course may help in that role. The course goes into detail on integrating modules, and on event-driven communication between modules. An integration engineer may benefit from learning the Outbox Pattern for reliable messaging, a topic that this course touches on. This course's focus on system design and module communication is related to the work of an integration engineer. Although not a complete preparation, this course may help with the work of an integration engineer.

See salaries and explore the career path for Integration Engineer

Cloud Engineer

Cloud engineers manage systems hosted in the cloud, and while not a direct connection, this course may be helpful. Cloud engineers need to understand system architecture, and this course covers some aspects of this, like Modular Monoliths and Vertical Slice Architecture. This course focuses on building applications with an eye towards scalable and maintainable development, which is crucial for cloud applications. Although it doesn't cover cloud systems directly, this course may be useful for cloud engineers looking to expand skills sets. The technologies used in this course may be deployed to cloud infrastructure by a cloud engineer.

See salaries and explore the career path for Cloud Engineer

Database Administrator

Database administrators manage and maintain databases, and while not a direct connection, this course may offer some useful skills. The course discusses setting up a PostgreSQL database with Entity Framework Core and migrations. While not a comprehensive course on database administration, this course may help a database administrator better understand the perspective of application developers. The database administration aspects of the course are an introduction, but may be helpful for a database administrator. Although the main focus of this role is not addressed, the course may be useful.

See salaries and explore the career path for Database Administrator

Data Engineer

Data engineers build and maintain data pipelines, and this course may be helpful to their work. The course focuses on architectural patterns and reliable messaging, which may be relevant to data pipeline design. A data engineer needs to understand how to manage data flow, and the course touches on this with the implementation of an Outbox Pattern. While the tools and technologies used by a data engineer are not directly taught in this course, some concepts may be useful. Though not a perfect fit, the course may be a stepping stone for a data engineer.

See salaries and explore the career path for Data Engineer

.NET 8 Backend Bootcamp

Modulith, VSA, DDD, CQRS and Outbox

What's inside

Learning objectives

Syllabus

Traffic lights

Save this course

Reviews summary

.net 8 modern backend architecture bootcamp

Activities

Career center

Reading list

Share

Similar courses