Does this sound familiar?

In the early days of your project, everything was great: the small code base was easy to understand, you could add features and fix bugs quickly, you could verify the whole app was working properly with just a few manual tests and you were able get a new version up and running any time your boss asked to show your progress.

A year later, your customers are loving your app, but now that your team has grown and you have to deal with thousands of lines of code, things are not fun anymore:

  • The code base is too complex to understand and explain to new team members, which makes adding new features and fixing bugs difficult and time consuming
  • Loading and building the code in your IDE keeps getting slower. It's painful to make even one-line changes
  • The app keeps breaking very frequently now that there are so many devs making changes at the same time. Even a small bug in a single module can break the whole thing
  • You keep missing deadlines. With so much to build and test, you can only release new bits once a month, and usually late on a Friday or Saturday night
  • Scaling to handle the increasing load is too hard. Getting new servers, configuring them, deploying your app there, etc. And when the load goes down, so much wasted server power.
  • Move to the latest .NET stack? Only a dream. It would mean rewriting a crazy amount of code, not to mention the time needed to verify all features keep working properly and reconfiguring your production environment for the latest tech

There must be a better way.

What are microservices?

Business aligned, loosely coupled services

Microservices are an architectural style that structures an application as a collection of autonomous, loosely coupled services that are modeled around a business domain. Each microservice is focused on doing one thing well.

Owned by small, focused teams

A microservice is small enough that a single feature team can own it. Small team sizes promote greater agility. Large teams tend be less productive, because communication is slower, management overhead goes up, and agility diminishes.

Built and deployed independently

A team can update an existing microservice without rebuilding and redeploying the entire application and roll back an update if something goes wrong. In traditional applications, a bug found in one part of the application, can block the entire release.

What Will You Get Inside?


Building Microservices With .NET is a complete program designed to transform the way you build .NET systems at scale so that they are resilient, secure, easy to maintain, and ready to handle constantly changing business requirements and production demands.

The program includes everything you need to achieve a successful and joyful microservices implementation in your organization.

Includes 4 Premium Online Courses


1. Building Microservices With .NET

  • Go from zero to a complete .NET microservices based system, step by step
  • Build complete microservices REST APIs powered by real databases
  • Avoid code duplication across microservices
  • Maximize service availability with the best inter-service communication patterns
  • Protect your microservices with state-of-the-art security tools and protocols
  • Handle any complex business requirements via long running transactions



Tech Stack


2. Unlock The Power Of Microservices In The Azure Cloud

  • Handle production demands, minimize operational issues and save a lot of money running microservices in Microsoft Azure
  • Structure microservices code in the cloud for maximum flexibility
  • Run your microservices everywhere with Docker
  • Simplify your microservices infrastructure with essential Azure services
  • Let Kubernetes unlock the power of your microservices in the Azure cloud
  • Securely store all your microservice secrets in the cloud
  • Make things really easy for your client apps with a popular API Gateway



Tech Stack


3. Automate All The Things With DevOps

  • Create a fully automated delivery pipeline to go from your box to the cloud in seconds (not hours)

  • Simplify and speed up your microservices deployment with powerful templates

  • Catch build issues as soon as they show up (and get fixes out in seconds)

  • Push your code and go home, while the automated pipeline does the rest



Tech Stack


4. Microservices Troubleshooting Essentials

  • Be the first to know when things go wrong and get everything sorted out way before your customers start noticing.

  • Never be blind again in Prod with real time logs you can query from anywhere

  • Quickly identify bottlenecks and points of failure with end-to-end distributed tracing

  • Always stay on top of the performance of your system with a state-of-the-art monitoring solution



Tech Stack


Included With Every Course

Signature Online Video Training

Lifetime access to professionally recorded high quality video training that you can take at your own pace, anywhere and from any device.

Beautifully Illustrated Handouts

Includes all diagrams from every slide deck presented across the course, so you can reference them any time.

Course Roadmap

A printable roadmap covering all the modules included in the course, so you never get lost.

Full Source Code

Full source code linked to every coding lesson so you can easily compare and troubleshoot.

Step By Step Lesson Scripts

Speed up your learning with the exact written steps the instructor follows during the videos.

Full English captions

In case you need them, English captions can be turned on quickly for any of the lessons.

Course Certificates

Get a certificate of completion when you finish each course to show off on your LinkedIn profile.


Bonus #1: Ready To Go Frontend Portal

  • A modern and user-friendly frontend portal designed to interact with .NET microservices

  • See how your microservices can power an actual user experience

  • Discover what nobody else teaches you about frontend to backend interaction

  • No need to code it. Just build it and run it, in your box or in the cloud!

Bonus #2: Quick Reference Cheat Sheets


A collection of super concise, straight to the point cheat sheets to print and have next to your keyboard so you never have to remember those elusive commands from memory again.


Bonus #3: The .NET Microservice Template

  • No need to keep creating .NET microservices from scratch, or copying code around

  • Scafold a fully featured .NET microservice with a single command!

  • Generates a complete REST API, with preconfigured database access, message publishing, health checks, Dockerfile, deployment files, CI/CD pipeline, and more!


Bonus #4: Community Access

  • Post your questions to the community spaces, the Discord server or the on-lesson discussion sections. Either way, you'll get an answer in less than 24 hours.

  • Community members can interact with each other, support each other, answer each other's questions and get inspiration.


Bonus #5: Simplifying your ASP.NET Core Code Module

  • Learn to use the minimal hosting model to minimize the code required to start your application

  • Significantly reduce the amount of using directives in your classes via the implicit usings feature

  • Use file scoped namespaces to make your code more readable

  • Use nullable reference types and the required modifier to minimize the chances of running into common errors

Program Curriculum

Building Microservices With .NET

01 Welcome to the course! 5 lessons
  • Course Introduction
  • Development environment setup
  • Customizing VS Code for C# Development
  • What's wrong with the monolith?
  • What are microservices?
02 Your first microservice 6 lessons
  • Creating a microservice via the .NET CLI
  • Preparing the initial project files
  • Introduction to the REST API and DTOs
  • Adding the DTOs
  • Adding the REST API operations
  • Handling invalid inputs
03 Adding database storage 7 lessons
  • Introduction to the repository pattern and MongoDB
  • Implementing a MongoDB repository
  • Using the repository in the controller
  • Introduction to Docker
  • Trying out the REST API with a MongoDB container
  • Introduction to Dependency Injection and Configuration
  • Implementing dependency injection and configuration
04 Preparing for the next microservice 7 lessons
  • Using Postman
  • Reusing common code via NuGet
  • Refactoring into a generic MongoDB repository
  • Refactoring MongoDB registration into extension methods
  • Moving generic code into a reusable NuGet package
  • Introduction to Docker Compose
  • Moving MongoDB to docker compose
05 Synchronous inter-service communication 8 lessons
  • Creating the Inventory microservice
  • Introduction to synchronous communication
  • Implementing synchronous communication via IHttpClientFactory
  • Understanding timeouts and retries with exponential backoff
  • Implementing a timeout policy via Polly
  • Implementing retries with exponential backoff
  • Understanding the circuit breaker pattern
  • Implementing the circuit breaker pattern
06 Asynchronous inter-service communication 7 lessons
  • Introduction to asynchronous communication
  • Defining the message contracts
  • Publishing messages via MassTransit
  • Standing up a RabbitMQ docker container
  • Refactoring MassTransit configuration into the reusable NuGet package
  • Consuming messages for eventual data consistency
  • Removing the inter-service synchronous communication
07 Initial Frontend Integration 5 lessons
  • Installing Node.js
  • Getting started with the frontend
  • Understanding CORS
  • Adding the CORS middleware
  • Exploring the frontend to microservices communication
08 Identity in Microservices 4 lessons
  • Introduction to ASP.NET Core Identity
  • Creating the Identity microservice
  • Integrating ASP.NET Core Identity with MongoDB
  • Adding the Users REST API
09 Microservices Security Patterns and Techniques 4 lessons
  • Microservices authentication
  • Introduction to OAuth 2.0
  • Introduction to OpenID Connect
  • Introduction to IdentityServer
10 Implementing Microservices Security 7 lessons
  • Setting up IdentityServer
  • Requesting tokens via Postman
  • Understanding JSON Web Tokens
  • Securing the Catalog microservice
  • Generalizing how to add authentication to microservices
  • Securing the Inventory microservice
  • Securing the Identity microservice
11 Authorization in Microservices 6 lessons
  • Storing secrets during local development
  • Understanding Authorization in ASP.NET Core
  • Seeding users and roles
  • Adding users to the Player role
  • Implementing role-based authorization
  • Implementing claims-based authorization
12 Frontend Integration to Secure Microservices 6 lessons
  • Configuring CORS in the Identity microservice
  • Adding the frontend client to the IdentityServer configuration
  • Fixing the logout experience
  • Using ID tokens in the frontend client
  • Using access tokens in the frontend client
  • Fixing the user registration experience
13 Transactions with Microservices 4 lessons
  • Database Transactions
  • Distributed Transactions
  • Introduction to Sagas
  • Choreographed VS Orchestrated Sagas
14 Preparing the Saga participants 5 lessons
  • Purchase Saga Overview
  • Publishing Catalog prices
  • Allowing services to customize the retry configuration
  • Granting and subtracting items via asynchronous messages
  • Debiting gil via asynchronous messages
15 Implementing the Purchase Saga 11 lessons
  • Creating a MassTransit state machine
  • Initializing the state machine
  • Adding the Purchase controller
  • Configuring the Trading microservice
  • Trying out the state machine
  • Querying the state machine via a controller action
  • Consuming Catalog prices in the Trading microservice
  • Adding a custom state machine activity
  • Sending and consuming Inventory messages from the state machine
  • Unsing the MassTransit In-Memory Outbox
  • Sending and consuming Identity messages from the state machine
16 Compensation and Idempotency 6 lessons
  • Compensating actions in the state machine
  • Idempotency in microservices
  • Adding idempotency to a controller action
  • Handling out of order messages in the state machine
  • Handling message duplication
  • Implementing idempotent consumers
17 The Frontend Store Experience 9 lessons
  • Store experience overview
  • Publishing inventory updated events
  • Publishing user updated events
  • Consuming Inventory and Identity events in the Trading microservice
  • Implementing the Store controller
  • Trying out the updated Frontend portal
  • Real-time updates via SignalR
  • Configuring SignalR authentication
  • Sending real-time updates from the state machine via SignalR

Unlock the Power of Microservices in the Azure Cloud

18 Microservices and Source Control 5 lessons
  • Monorepo vs Multirepo
  • Installing Git
  • Using Git to add files to source control
  • Creating a GitHub organization
  • Uploading files to a GitHub repository
19 Publishing NuGet Packages to GitHub 4 lessons
  • Preparing NuGet packages for GitHub
  • Generating a GitHub Personal Access Token
  • Publishing to GitHub Packages
  • Consuming a NuGet package from GitHub
20 Dockerizing your microservices 6 lessons
  • Running your microservice anywhere via Docker
  • Preparing the Identity microservice for Docker
  • Adding a Dockerfile
  • Consuming NuGet packages within a Dockerfile
  • Building a Docker image
  • Running a Docker container
21 Getting Started with Microsoft Azure 3 lessons
  • Creating an Azure account
  • Installing the Azure CLI
  • Creating an Azure resource group
22 Using Azure Cosmos DB 3 lessons
  • Creating a Cosmos DB account
  • Adding Cosmos DB support to the Common library
  • Using Cosmos DB in a microservice
23 Using Azure Service Bus 3 lessons
  • Creating a Service Bus namespace
  • Adding Service Bus support to the Common library
  • Using Service Bus in a microservice
24 Using the Azure Container Registry 2 lessons
  • Creating an Azure Container Registry
  • Publishing Docker images to Azure Container Registry
25 Deploying microservices to Azure Kubernetes Service 6 lessons
  • Introduction to Kubernetes
  • Creating a Kubernetes cluster
  • Defining a Kubernetes deployment
  • Using Kubernetes secrets
  • Creating a Kubernetes pod
  • Creating a Kubernetes service
26 Reporting the microservices health 5 lessons
  • Adding a basic health check
  • Creating a custom database health check
  • Configuring a custom database health check
  • Adding Kubernetes health probes
  • Generalizing the health check configuration
27 Storing Secrets in Azure Key Vault 5 lessons
  • Creating an Azure Key Vault
  • Reading secrets from Azure Key Vault
  • Configuring Azure AD workload identity on AKS
  • Reading Azure Key Vault secrets from your pods
  • Generalizing the Azure Key Vault configuration
28 Adding the API Gateway 6 lessons
  • Introduction to the API Gateway
  • Installing Helm
  • Installing the Emissary-ingress API Gateway
  • Configuring Routing to a Microservice
  • Running the Identity microservice behind the API gateway
  • Using Postman environments
29 Enabling HTTPS and TLS Termination 6 lessons
  • Installing cert-manager
  • Generating a TLS certificate
  • Enabling HTTPS and TLS termination in Emissary-ingress
  • Forwarding headers to the Identity microservice
  • Creating a signing certificate
  • Using the signing certificate in the Identity microservice
30 Running the system in Production 2 lessons
  • Deploying the Catalog microservice to AKS
  • Trying out the Frontend in Production

Automate All The Things With DevOps

31 Using Helm charts to simplify microservices deployment 7 lessons
  • Creating a Helm chart (Part 1)
  • Creating a Helm chart (Part 2)
  • Creating a Helm chart (Part 3)
  • Deploying a microservice using a Helm chart
  • Generalizing the Helm chart
  • Publishing a Helm chart to ACR
  • Deploying a microservice using a Helm chart from ACR
32 Microservices and Continuous Integration 5 lessons
  • Introduction to CI/CD
  • Creating a CI/CD pipeline with GitHub Actions
  • Generating version numbers via GitHub Actions
  • Publishing NuGet packages via GitHub Actions
  • Building docker images via GitHub Actions
33 Microservices and Continuous Deployment 4 lessons
  • Authenticating GitHub repositories with Azure
  • Logging in to Azure via GitHub Actions
  • Publishing docker images via GitHub Actions
  • Deploying a microservice to AKS via GitHub Actions

Microservices Troubleshooting Essentials

34 Adding Logging 8 lessons
  • Introduction to Logging
  • Writting logs via ILogger
  • Standing up a Seq Docker container
  • Sending logs to Seq in your local box
  • Generalizing the Seq configuration
  • Deploying Seq to Kubernetes
  • Adding Seq support to the microservice helm chart
  • Sending logs to Seq in AKS
35 Adding Distributed Tracing 11 lessons
  • Introduction to Distributed Tracing
  • Upgrading the Common library to MassTransit v8
  • Upgrading all microservices to MassTransit v8
  • Using OpenTelemetry to collect and export distributed traces
  • Standing up a Jaeger Docker container
  • Exporting distributed traces to Jaeger
  • Generalizing the distributed tracing configuration
  • Adding distributed tracing to all microservices
  • Deploying Jaeger to Kubernetes
  • Adding Jaeger support to the microservice helm chart
  • Sending distributed traces to Jaeger in AKS
36 Adding Monitoring 7 lessons
  • Introduction to Monitoring
  • Using OpenTelemetry to collect and export metrics
  • Standing up a Prometheus Docker container
  • Generalizing the monitoring configuration
  • Deploying Prometheus and Grafana to Kubernetes
  • Letting Prometheus discover microservices in AKS
  • Getting a microservice monitored by Prometheus and Grafana in AKS

Bonus Module

37 Simplifying your ASP.NET Core Code 4 lessons
  • Using the Minimal Hosting Model
  • Enabling Implicit Usings
  • Using File Scoped Namespaces
  • Using Nullable Reference Types and the Required modifier

Program Preview


Get the Mobile App

  • Get access to all course lessons and discussions anywhere, anytime, on any device.

  • The mobile app is the best way to stay in the loop and take your learning to the next level.

  • Available for both iOS and Android, the mobile app works great as a native learning experience.

Meet Your Instructor


My name is Julio Casal. I'm a passionate software engineer with a wealth of experience building all sorts of applications and systems based on the .NET platform.

Throughout my 10+ years working at Microsoft, I had the opportunity to work on real-world projects, building and refining backend services that handle millions of requests every month.

I believe reducing complex concepts into simple step by step instructions is incredibly valuable and helps to make coding accessible and fun for everyone.

Compared to Other Programs

Other .NET Microservices Programs
Building Microservices With .NET
  • Only give you a list of pre-recorded videos with source code that some times won't match what the instructor is doing.
  • Complements professionally recorded videos with fully working source code, step by step lesson scripts, complete course roadmaps, fully illustrated handouts, full English captions, cheat sheets and a powerful project template.
  • Focus only on some aspects of .NET microservices development.
  • Covers everything involved in .NET microservices development, from writing your very first microservice from scratch, to securing your system, taking it to the cloud, adding CI/CD pipelines and even adding all the essential observability components.
  • Are scattered all over the web and taught by multiple instructors
  • Provides a consistent learning path, carefully crafted by Julio and specifically designed to teach microservices development from start to finish.
  • Usually involve copy pasted code and the instructor won't always explain the concepts behind what he is doing.
  • Every line of code is written and explained during the video lessons and all concepts, patterns and techniques are explained with didactic visuals before writting any code.

More Happy Customers

Start Building Microservices With .NET Today!

This Program
All Courses
$ 497
one-time payment

  • Building Microservices With .NET Training
  • Full Source Code
  • Full English Captions
  • Course Roadmap
  • Course Certificate
  • Unlock The Power Of Microservices In The Azure Cloud Training
  • Beautifully Illustrated Handouts
  • Step By Step Lesson Scripts
  • Community Access
  • Automate All The Things With DevOps Training
  • Microservices Troubleshooting Essentials Training
  • Quick Reference Cheat Sheets
  • The .NET Microservice Template
  • Simplifying your ASP.NET Core Code Training
one-time payment

  • Building Microservices With .NET Training
  • Full Source Code
  • Full English Captions
  • Course Roadmap
  • Course Certificate
  • Unlock The Power Of Microservices In The Azure Cloud Training
  • Beautifully Illustrated Handouts
  • Step By Step Lesson Scripts
  • Community Access
  • Automate All The Things With DevOps Training
  • Microservices Troubleshooting Essentials Training
  • Quick Reference Cheat Sheets
  • The .NET Microservice Template
  • Simplifying your ASP.NET Core Code Training
one-time payment

  • Building Microservices With .NET Training
  • Full Source Code
  • Full English Captions
  • Course Roadmap
  • Course Certificate
  • Unlock The Power Of Microservices In The Azure Cloud Training
  • Beautifully Illustrated Handouts
  • Step By Step Lesson Scripts
  • Community Access
  • Automate All The Things With DevOps Training
  • Microservices Troubleshooting Essentials Training
  • Quick Reference Cheat Sheets
  • The .NET Microservice Template
  • Simplifying your ASP.NET Core Code Training
full course library

  • Instant access to the entire course library
  • Continuous access to new courses and updates
  • Low monthly fee
  • Course certificates
  • Discord server access
  • Cancel anytime

Who is using microservices?


Top companies that are constantly dealing with very complex changing requirements have been embracing microservices for several years.

Only microservices allow teams to stay agile and autonomous, while also getting your system ready to scale when unexpected traffic peaks show up.


When does the program start and finish?

Building Microservices With .NET is a completely self-paced online program. You decide when you start and when you finish.

What version of .NET and ASP.NET Core is used on this program?

The courses where originally recorded using .NET 5. However, all obsolete lessons have been re-recorded to ensure you can follow along with the latest .NET 8 SDK. All source code downloads are also updated to .NET 8.

How many hours of video content are included in this program?

The total video content time of all four courses is 35 hours.

Can you provide an invoice to request reimbursement from my employer?

Yes, I can provide an invoice upon your request. I will only need you to provide billing details.

Do you offer a certification on course completion?

Yes, you will get a certificate at no additional cost after completing all the course lessons and assignments.

How long will I have access to the content?

Your enrollment includes unlimited lifetime access and free updates for life.

I have more questions!

Happy to help! Send me an email: [email protected]