Build the Production .NET Systems
Companies Actually Hire For

You know C# basics, but companies need developers who can build production-ready systems on Azure. There's a massive gap between tutorials and real-world applications.

Your current skills aren't enterprise-ready: You can build basic APIs, but haven't implemented real authentication or cloud deployment
The learning gap is massive: "Hello World" tutorials don't teach cloud-native, security-focused, production applications
You're competing against cloud experts: While you're still figuring out the basics, other developers are deploying containerized microservices with Infrastructure as Code
Ready to close the gap?

See The Full System In Action

A full walkthrough of the Game Store, the e-commerce app at the center of the Bootcamp.

Part 1 · API Foundations

Master the Essential .NET Web Development Stack

REST API Development
Vertical Slice Architecture
Dependency Injection
Entity Framework Core
Asynchronous Programming
Logging
Middleware
Error Handling
JWT Authentication
Authorization Policies
Keycloak Identity Provider
OAuth 2.0 & OpenID Connect
Build solid REST APIs

Build Solid REST APIs

  • REST Fundamentals: Stop building inconsistent APIs - master HTTP verbs, status codes, and resource conventions that other developers expect.
  • Client-Friendly Design: Build APIs that don't frustrate frontend teams - proper error handling and consistent response formats.
  • Minimal APIs: Build lightweight endpoints with simple functions - perfect for microservices and scenarios where full MVC controllers are overkill.
Vertical slice architecture in ASP.NET Core

Use Vertical Slice Architecture

  • Feature-Based Organization: Group everything for each feature together so you can find and modify related code in one place.
  • Reduced Coupling: Build features that don't break each other - each slice contains its own models and logic without shared dependencies.
  • Simple Changes Stay Simple: Stop touching 6 different files just to add one field - make feature changes in one focused area.
Dependency injection in ASP.NET Core

Stop Hardcoding Dependencies

  • Automatic Dependency Management: Register services once and let the container handle construction and injection - stop manually wiring dependencies.
  • Depend on Interfaces, Not Concrete Classes: Code against abstractions instead of specific implementations - swap implementations without changing business logic.
  • Cleaner, More Maintainable Code: Services focus on core responsibility instead of managing dependencies - easier to modify and reuse.
Entity Framework Core

Simplify Data Access with Entity Framework Core

  • Code-First Database Design: Define your database schema in C# classes and let EF generate the database - no more manual CREATE TABLE statements.
  • Type-Safe Database Queries: Write database queries using LINQ instead of raw SQL strings - catch errors at compile time, not in production.
  • Automatic Change Tracking: EF tracks entity modifications and generates INSERT, UPDATE, DELETE statements - stop writing tedious data access code.
Asynchronous Programming

Scale with Asynchronous Programming

  • Dramatically Better Scalability Under Load: Handle thousands of concurrent requests without blocking threads.
  • Responsive User Interfaces That Don't Freeze: Keep your UI reactive during long-running operations like API calls or file processing.
  • Efficient Resource Utilization: Free up expensive threads while waiting for I/O operations to complete - serve more users with the same hardware budget.
Logging

Production-Ready Logging

  • Master the Three Logging Approaches: Learn when to use WebApplication logger, ILoggerFactory, and ILogger - stop guessing which one fits your situation.
  • Configure Log Levels Like a Pro: Control what gets logged in different environments without touching your code - debug locally, stay clean in production.
  • Use ASP.NET Core's Built-In Infrastructure: Skip third-party logging libraries and use the framework's native logging that's already tuned for performance.
Middleware

Handle Cross Cutting Concerns With Middleware

  • Build Custom Cross-Cutting Logic: Create reusable middleware classes that handle concerns across your application - write once, apply everywhere.
  • Control Request Processing Order: Master the pipeline sequence to ensure middleware runs in the right order - no mysterious bugs.
  • Use Built-In HTTP Logging: ASP.NET Core's HTTP logging middleware gives detailed diagnostics with zero custom code.
Error Handling

Global Error Handling

  • Implement Global Exception Handling: Catch all unhandled errors in one place - no more scattered try-catch blocks.
  • Add Problem Details Support: Return standardized error responses that APIs and clients can actually use.
  • Catch and Log Errors Properly: Capture meaningful error data for debugging without exposing sensitive details.
File Upload

Secure File Uploads

  • Handle File Uploads Safely: Validate file types and sizes before saving - prevent your server from getting overwhelmed.
  • Avoid File Name Conflicts: Generate unique file names automatically - no more files overwriting each other.
  • Serve Uploaded Files Easily: Configure your app to serve uploaded images and documents directly to users.
Asynchronous Programming

Secure APIs with JWT Authentication

  • Decode and Understand JWTs: Learn JWT structure and how to quickly generate and read token contents using built-in .NET tooling.
  • Configure JWT Validation: Set up ASP.NET Core to properly validate incoming tokens and protect your minimal API endpoints.
  • Access JWT Claims in Endpoints: Extract user information from validated tokens in your API endpoints.
Logging

ASP.NET Core Authorization

  • Master All Authorization Types: Learn role-based, claims-based, policy-based, and resource-based authorization techiques.
  • Build Flexible Authorization Policies: Create reusable policies that combine claims and roles for complex access rules.
  • Secure Individual Resources: Implement resource-based authorization to control access to specific data records.
Keycloak

Professional Identity Management with Keycloak

  • Easy Local Setup: Run Keycloak locally with just Docker - learn industry standard authorization techniques hands-on without cloud complexity.
  • Developer-Friendly Admin: Manage users, roles, and permissions through a simple web interface - no custom admin code needed.
  • Straightforward ASP.NET Core Integration: Configure your API to validate Keycloak tokens and transform claims - production-ready identity integration made simple.
OIDC

OAuth 2.0 and OpenID Connect

  • Master the Authorization Code Flow: Understand the complete token exchange process with scopes, refresh tokens, and secure client configuration.
  • OAuth 2.0: Stop hardcoding authentication into every endpoint - delegate to a dedicated server that issues trusted tokens.
  • OpenID Connect: Get verified user identity (name, email, roles) right after OAuth login - standardized identity claims across any provider.
Enroll Now
Part 2 · Cloud & Deployment

The Cloud-Native Azure Toolkit Every .NET Dev Needs.

Azure App Service
Azure App Service
Entra ID
Azure PostgreSQL
Entra ID
Azure Storage
Entra ID
Azure Front Door
Entra ID
Managed Identities
Entra ID
Microsoft Entra ID
Entra ID
Azure Key Vault
Docker Containers
Azure Container Registry
Container Registry
Azure Container Apps
Azure Container Apps
Health Checks
Azure Bicep
Azure Bicep
Aspire
Aspire
Azure App Service

App Service: Deploy Without the Server Hassle

  • Deploy from VS Code: Push your .NET apps to Azure directly from VS Code with simple commands - no server configuration needed.
  • Managed .NET Hosting: Focus on writing code instead of managing servers - Azure handles scaling and uptime automatically.
  • Azure-Native Configuration: Use built-in environment variables and connection strings - production-ready apps without complex setup.
Microsoft Entra ID

Production Identity Management with Entra ID

  • Production-Ready Integration: Stop running your own identity server - integrate with Microsoft's managed service that handles scaling and security updates.
  • Complex Configuration Simplified: Stop getting lost in Microsoft's confusing docs - learn the exact steps to integrate .NET apps with Entra ID without frustration.
  • Complete Identity Management: Manage users, roles, and permissions through Entra's admin portal - no more building custom login flows.
Docker Desktop

Azure Storage: File Storage Without Limits

  • Offload File Storage: Stop storing uploads on your server's disk - let Azure handle file storage while your .NET app stays lightweight.
  • Simple .NET Integration: Upload, download, and manage files with Azure's .NET SDK - no complex file management needed.
  • Infinite Scalability: Handle millions of files without worrying about disk space - Azure Storage scales automatically as your app grows.
Azure Front Door

Global File Delivery with Azure Front Door

  • Global Performance: Deliver images from the nearest Azure edge location - faster downloads for customers worldwide.
  • Hide Storage URLs: Serve files through custom domain names instead of exposing your actual Azure Storage account URLs.
  • Handle Traffic Spikes: Let Azure's CDN absorb sudden traffic surges - your storage account stays protected from overload.
Docker Desktop

Passwordless Azure Authentication

  • Passwordless Azure Access: Stop hardcoding connection strings and API keys - let Azure automatically authenticate your services.
  • Zero Credential Management: Eliminate password rotation and secret storage complexity - Azure handles authentication automatically.
  • Secure by Default: Access Storage, databases and more without storing any secrets in config files or environment variables.
Managed PostgreSQL Database

Production-Grade PostgreSQL Database

  • Managed Infrastructure: Stop managing database servers - Azure handles patching, backups, and scaling automatically.
  • Passwordless Database Access: Connect using managed identities - no database passwords or credentials in your .NET code.
  • High Availability: Ensure 99.99% uptime with automatic failover and backups - focus on code, not database maintenance.
Azure Key Vault

Secure Secret Management with Key Vault

  • Secure Secret Storage: Stop hardcoding API keys in config files - store sensitive data encrypted in Azure's secure vault.
  • Easy .NET Integration: Access secrets programmatically using .NET configuration system - it plugs directly into your apps.
  • Centralized Access Control: Manage who accesses which secrets across environments - audit trails and rotation included.
Docker Desktop

Transform .NET Apps Into Bulletproof Containers

  • Finally understand what containers actually are and why you need them
  • Build, run, and test your .NET apps as containers, ready to publish to the cloud
  • Build container images 45% smaller using optimizations and best practices
  • Use modern .NET tooling to skip complex Docker commands and avoid typical errors
Azure Container Apps

Production Containers Made Simple with Container Apps

  • Deploy production containers without becoming a Kubernetes expert
  • Pay $0 when nobody's using your app with automatic scale-to-zero
  • Sleep better with auto-scaling that handles traffic spikes
  • Rollback disasters in 30 seconds with revision management
Health Checks

Build Self-Healing APIs

  • Automatic Recovery from Failures: Azure restarts your containers automatically when health checks fail - no more midnight calls to manually restart crashed APIs.
  • Monitor Your Entire Stack: Health checks verify your database, storage, external APIs, and every dependency - complete visibility into what's working.
  • Prevent Bad Deployments: New container versions won't receive traffic until they pass health checks, protecting your users from broken releases.
Aspire dashboard showing every service running after one F5

Hit F5 and Your Whole System Boots

  • Clone, F5, ready: one keystroke boots every service, database, and frontend in dependency order. The clone, crash, fix, crash, fix morning is gone.
  • One stack, every machine: your whole system is declared once in C# and checked into git, so every teammate and every laptop runs exactly what you run.
  • No setup scripts: no docker-compose.yml, no shell scripts, no "run these 7 commands first" README. The application model is the setup.
Aspire AppHost in C#

Define Your Entire System in C#

  • One model, every dependency: declare your databases, caches, queues, identity, and your own services in a single C# AppHost project.
  • Add a dependency in 1 line: drop in Postgres, Redis, Key Vault, or Azure Storage, and Aspire owns the lifecycle, wiring, and connection strings.
  • No connection-string plumbing: .WithReference injects the config into each service, and .WaitFor holds startup until it's healthy.
Aspire dashboard

Production-Ready Defaults, Not Boilerplate

  • Skip ~40 lines per service: one AddServiceDefaults() call wires resilience (retries, timeouts, circuit breakers), service discovery, and health endpoints.
  • Health and traces on first F5: a built-in dashboard shows distributed traces, logs, metrics, and the health of every service. No Jaeger, Prometheus, or Grafana to set up.
  • Find the slow call in seconds: follow one request across your API, database, and external services with real timing.
Azure resource group provisioned by azd

Same Model, Dev to Production

  • Deploy with one command: azd up provisions the resource group, pushes your images, and stands up an Azure Container App per service.
  • Dev, QA, and prod match: every environment is generated from the same C# model in git, so what you tested is what ships.
  • Go beyond the defaults with Bicep: drop down to Bicep for any Azure resource or setting Aspire doesn't cover, referenced straight from the AppHost.
Enroll Now
Part 3 · Scale & Resilience

Build Production-Ready Systems with Queues, Workers, and Transactions

Learn the patterns and techniques that separate junior developers from senior engineers, by building a real e-commerce system with queues, workers, transactions, webhooks, and the outbox pattern, all integrated and deployed to Azure.

Stripe Checkout
Webhook Processing
Transactions & Data Consistency
Idempotency Patterns
Azure Service Bus Queues
The Outbox Pattern
Background Workers
Checkout

Accept Secure Payments with Stripe

  • Create secure checkout sessions using the Stripe API and handle the complete payment lifecycle
  • Use Stripe's ready-made SDKs, pre-built checkout forms, and solid libraries to simplify integration.
  • Let Stripe handle PCI compliance, fraud detection, and regulatory requirements automatically.

Instant Notifications with Webhooks

  • Receive instant notifications from Stripe the moment transactions complete using secure webhook endpoints
  • Eliminate inefficient polling patterns that waste resources and introduce delays
  • Ensure events are authentic and protect your system from malicious requests
transactions

Ensure Data Consistency with Transactions

  • Avoid data inconsistencies when coordinating operations across multiple database tables.
  • Use database transactions to ensure multiple operations succeed or fail together, preventing data inconsistencies.
  • Use execution strategies to automatically retry failed transactions caused by transient errors

Scale Safely with Queues and Workers

  • Implement message queues using Azure Service Bus to decouple services and handle async operations reliably at scale.
  • Build background worker services that process queued messages independently from your API, improving responsiveness and resilience.
  • Implement the outbox pattern to reliably publish messages, ensuring no events are lost.

Deploy to Production on Azure

  • Deploy your complete e-commerce system to Azure with one command.
  • Experience your frontend and backend working together in Azure, with PostgreSQL, Service Bus and Stripe integration.
  • Define your entire application model with Aspire and infrastructure as code.

Two Frontend Stacks Included

Make your backend API shine by integrating it with the included Blazor and React frontends, so you can see how your API works in a real-world scenario.

Blazor frontend for the Game Store app
React frontend for the Game Store app
Blazor

Static Server-Side Rendered (SSR) Application

React

Vite Single Page Application (SPA)

Game Store app running in the browser
Two frontend stacks, same user experience

Build and Ship Modern .NET Systems

Learn how to use the latest cloud-native tools and practices to build resilient, maintainable .NET systems.

Building and shipping modern .NET systems
Enroll Now

A complete learning path across 7 premium courses

Bootcamp learning path progression

Course 1: ASP.NET Core Essentials

Welcome to the course! 9min
  • Course introduction
  • Bootcamp structure
  • What this course covers
  • Is this course for you?
  • Software prerequisites
Getting started with ASP.NET Core 51min
  • Introduction to ASP.NET Core
  • Development environment setup
  • Creating a Web project
  • Exploring the Web project
  • Building a Web project
  • Running and debugging a Web project
  • Using the REST Client extension
Building a REST API with ASP.NET Core 1hr 16min
  • What is a REST API?
  • Interacting with REST APIs
  • Adding the data model
  • Implementing a GET ALL endpoint
  • Implementing a GET BY ID endpoint
  • Implementing the POST endpoint
  • Adding Server-Side Validation
  • AddValidation() vs WithParameterValidation()
  • Implementing the PUT endpoint
  • Implementing the DELETE endpoint
Using Data Transfer Objects 42min
  • Expanding the data model
  • Understanding Data Transfer Objects
  • Using DTOs with GET requests
  • Using DTOs with POST requests
  • Using DTOs with PUT requests
Vertical Slice Architecture 50min
  • Encapsulating the data
  • Using the encapsulated data
  • Introduction to Vertical Slice Architecture
  • Adding the first vertical slice
  • Adding the next slices
  • Adding the final slices
  • Using route groups
Dependency injection 41min
  • Understanding dependency injection
  • Understanding service lifetimes
  • Using transient services
  • Using scoped services
  • Using singleton services
Entity Framework Core and Configuration 58min
  • Introduction to Entity Framework Core
  • Preparing the data model for EF Core
  • Creating the DBContext
  • Configuring the DBContext
  • Introduction to ASP.NET Core configuration
  • Using ASP.NET Core configuration
  • Generating database migrations
  • Applying a database migration
  • Migrating the database when the app starts
Working with data 35min
  • Data seeding
  • Creating new database records
  • Querying single records from the database
  • Updating existing database records
  • Querying all records from the database
  • Deleting records from the database
  • Final queries and clean up
UI Integration 23min
  • Configuring the Blazor front-end
  • Running the Blazor front-end and .NET back-end together
  • Configuring the React front-end
  • Running the React front-end and .NET back-end together
ASP.NET Core Essentials

Course Includes

  • 9 Modules, 59 Lessons
  • 6.5 Hours of Video
  • Full source code
  • Illustrated handouts
  • Course Certificate
Enroll Now

Course 2: ASP.NET Core Advanced

Welcome to the course! 4min
  • Course introduction
  • What this course covers
  • What you need to know first
  • Software prerequisites
Asynchronous Programming 27min
  • Understanding the asynchronous programming model
  • Using tasks
  • Using asyc and await
  • Going async all the way
Logging 29min
  • Introduction to logging in ASP.NET Core
  • Sending logs via the WebApplication logger
  • Using ILoggerFactory
  • Using ILogger
  • Configuring log levels
Middleware 28min
  • Introduction to middleware
  • Adding middleware via a request delegate
  • Creating a middleware class
  • Use the HTTP logging middleware
Error Handling 34min
  • When things go wrong
  • Add problem details support
  • Catching and logging errors
  • Implementing a global exception handler
Implementing Pagination and Search 27min
  • Adding DTOs for pagination
  • Implementing pagination
  • Trying out pagination
  • Implementing basic search
  • Implementing case insensitive search
Using Postman and OpenAPI 28min
  • Configuring Postman
  • Sending requests
  • Adding OpenAPI support
  • Importing OpenAPI specifications to Postman
  • Using the generated Postman collection
Uploading Files 43min
  • File upload options
  • Implementing a file uploader
  • Updating the data model and DTOs
  • Updating the endpoints
  • Uploading files via Postman
  • Dealing with antiforgery
  • Serving static files
UI Integration 16min
  • Configuring the Blazor front-end
  • Running the Blazor front-end and .NET back-end together
  • Configuring the React front-end
  • Running the React front-end and .NET back-end together
ASP.NET Core Advanced

Course Includes

  • 9 Modules, 42 Lessons
  • 4 Hours of Video
  • Full source code
  • Illustrated handouts
  • Course Certificate
Enroll Now

Course 3: ASP.NET Core Security

Welcome to the course! 4min
  • Course introduction
  • What this course covers
  • What you need to know first
  • Software prerequisites
Authentication in ASP.NET Core 46min
  • Why authentication?
  • What is token based authentication?
  • Understanding JSON Web Tokens
  • Creating JWTs
  • Decoding a JWT
  • Configuring JWT authentication
  • Sending requests with JWTs
  • Using JWT claims in ASP.NET Core
  • Disabling the default claims mapping
The Shopping Basket API 39min
  • Adding the Shopping Basket data model
  • Implementing the Upsert Basket feature
  • Testing the Upsert Basket feature
  • Implementing the Get Basket feature
Authorization in ASP.NET Core 1hr 6min
  • Why authorization?
  • Types of authorization in ASP.NET Core
  • Requiring authorization in API endpoints
  • Using role-based authorization
  • Using claims-based authorization
  • Using policy-based authorization
  • Refactoring the authorization policy
  • Configuring a fallback policy and anonymous access
  • Implementing an authorization handler
  • Using resource-based authorization
Setting Up Keycloak 43min
  • Introduction to Keycloak
  • Introduction to Docker
  • Running Keycloak as a Docker container
  • Introduction to Docker Compose
  • Running Keycloak via Docker Compose
  • Creating a realm
  • Creating users
  • Creating and assigning roles
  • Exporting the realm configuration
The OAuth 2.0 framework 50min
  • Introduction to OAuth 2.0
  • Understanding the Authorization Code Flow
  • Configuring a client in Keycloak
  • Requesting access tokens from Keycloak
  • Configuring scopes and audience in Keycloak
  • Using refresh tokens
  • Getting access tokens in Postman
Using Keycloak JWTs in ASP.NET Core 1hr
  • Configuring a Keycloak authentication scheme
  • Receiving Keycloak JWTs in protected endpoints
  • Logging JWT events
  • Configuring the role claim in Keycloak
  • Implementing a claims transformer
  • Refactoring the authentication configuration
  • Using Keycloak's email claim
The OpenID Connect protocol 26min
  • Introduction to OpenID Connect
  • Requesting ID Tokens from Keycloak
  • Exploring the OIDC discovery endpoint
  • Exploring the UserInfo endpoint
  • Exploring the JSON Web Key Set
UI Integration 53min
  • Configuring the Blazor front-end
  • Running the Blazor front-end and .NET back-end together
  • The Blazor OIDC configuration explained
  • Configuring the React frontend
  • Running the React front-end and .NET backend together
ASP.NET Core Security

Course Includes

  • 9 Modules, 60 Lessons
  • 6 Hours of Video
  • Full source code
  • Illustrated handouts
  • Course Certificate
Enroll Now

Course 4: Azure For .NET Developers

Welcome to the course! 5min
  • Course introduction
  • What this course covers
  • What you need to know first
  • Software prerequisites
Cloud computing and Azure 40min
  • What is cloud computing?
  • The shared responsibility model
  • Cloud service models
  • What is Microsoft Azure?
  • Getting Azure credits
  • Interacting with Azure resources
  • Azure infrastructure basics
  • Azure hosting options
Azure App Service 1hr 4min
  • What is App Service?
  • Creating a resource group
  • Creating an App Service Web App
  • Preparing your app for deployment
  • Deploying your app to App Service
  • Exploring your Web App deployment
  • Automating the Web App deployment
  • Using Postman environments
  • Using logging in App Service
Microsoft Entra 1hr 59min
  • What is Microsoft Entra?
  • Creating an Entra External ID tenant
  • Registering the backend with Entra
  • Adding API scopes
  • Registering the Postman client
  • Creating users
  • Getting access tokens from Entra
  • Exploring Entra access tokens
  • Creating and assigning roles
  • Configuring the Entra scheme in the backend
  • Fixing the role claim
  • Fixing the scope claim
  • Adding a UserId claim
  • Adding multi scheme support
  • Enabling the email claim
  • Deploying your app with Entra support
Azure Storage 53min
  • What is Azure Storage?
  • Implementing an Azure Storage file uploader
  • Registering the BlobServiceClient
  • Running the Azurite emulator
  • Testing file upload with the Azurite emulator
  • Creating a Storage Account in Azure
  • Configure the Web App connection to Storage
  • Deploying your app with Azure Storage support
Azure Front Door 37min
  • What is Azure Front Door?
  • Enable Front Door for a Storate Account
  • Configuring your Front Door endpoint in your Web App
  • Implementing a CDN URL transformer
  • Using the CDN URL transformer
  • Deploying your app with Front Door support
Azure Managed Identities 46min
  • What are Managed Identities?
  • Enabling a System Assigned Managed Identity
  • Granting permissions to a Managed Identity
  • Use a Managed Identity in your Backend
  • Deploying your app with System Assigned Managed Identity support
  • Enabling logging in the Azure SDK
  • Creating a User Assigned Managed Identity
  • Associating your User Assigned Managed Identities to your Web App
  • Using your User Assigned Managed Identity in the Backend
  • Deploying your app with User Assigned Managed Identity support
Azure Database for PostgreSQL 1hr 24min
  • What is Azure Database for PostgreSQL?
  • Using the Npgsql database provider
  • Generating a PostgreSQL EF migration
  • Adding entity type constraints
  • Running PostgreSQL as a Docker container
  • Running backend with PostgreSQL locally
  • Creating an Azure Database for PostgreSQL server
  • Creating a passwordless connection to the PostgreSQL database
  • Preparing the DefaultAzureCredential for reuse
  • Configuring the backend connection to PostgreSQL via the Managed Identity
  • Deploying your app with PostgreSQL support
Blazor front-end deployment 43min
  • Registering the Blazor front-end in Microsoft Entra
  • Configuring the Blazor front-end for local development
  • Running the Blazor front-end locally
  • Enabling user registration in Entra
  • Configuring the Blazor front-end Azure Web App
  • Deploying the Blazor front-end to the Azure Web App
Azure Key Vault 23min
  • What is Azure Key Vault?
  • Creating a Key Vault
  • Setting Key Vault permissions
  • Assigning a managed identity to the front-end Web App
  • Configuring front-end environment variables
  • Adding secrets to Key Vault
  • Deploying the front-end with Key Vault support
React front-end deployment 31min
  • Registering the React front-end in Microsoft Entra
  • Configuring the React front-end for local development
  • Running the React front-end locally
  • Creating the React front-end Static Web App
  • Deploying the React front-end to the Azure Static Web App
  • Running the React front-end as an Azure Static Web App
Azure For .NET Developers

Course Includes

  • 11 Modules, 91 Lessons
  • 9 Hours of Video
  • Full source code
  • Illustrated handouts
  • Course Certificate
Enroll Now

Course 5: Docker for .NET Developers

Welcome to the course! 4min
  • Course introduction
  • What this course covers
  • What you need to know first
  • Software prerequisites
Docker fundamentals 25min
  • Why containers?
  • Docker Desktop architecture
  • Images vs containers
  • Docker tags
  • Port mapping
  • Docker volumes
  • Docker compose
Creating container images with Dockerfiles 58min
  • How a container image is created
  • Preparing the app for containerization
  • Writing a Dockerfile
  • Building a container image
  • Running a container
  • Talking to container from Postman
  • Multi-stage builds
  • Image versioning
Creating container images with .NET 26min
  • How to create images with the .NET SDK
  • Using dotnet publish to create images
  • Configuring container image properties
  • Making smaller container images
Publishing to Azure Container Registry 20min
  • Introduction to Azure Container Registry (ACR)
  • Creating an Azure Container Registry
  • Publishing to an ACR via Docker
  • Publishing to an ACR via the .NET CLI
Azure Container Apps 1hr 8min
  • What is Azure Container Apps?
  • Creating an Azure Container Apps Environment
  • Granting managed identity access to ACR
  • Creating a Container App
  • Configuring environment variables
  • Fixing data protection issues
  • Enable Ingress
  • Testing the API backend in Azure Container Apps
  • Creating new revisions
  • Scaling a Container App
Health checks 44min
  • The need for health checks
  • Implementing a basic health check
  • Adding a database health check
  • Adding a Storage health check
  • Separating liveness and readiness checks
  • Configuring health probes in Azure Container Apps
  • Restricting health endpoints
Docker for .NET Developers

Course Includes

  • 7 Modules, 44 Lessons
  • 4 Hours of Video
  • Full source code
  • Illustrated handouts
  • Course Certificate
Enroll Now

Course 6: Aspire for .NET Developers

Welcome to the course! 4min
  • Course introduction
  • What this course covers
  • What you need to know first
  • Software prerequisites
Getting started with Aspire 29min
  • What is Aspire?
  • Running the startup project
  • Adding the Aspire AppHost project
  • Running an Aspire application
  • Adding the .NET API to the AppHost
Defining your architecture 51min
  • Adding the PostgreSQL hosting integration
  • Connecting the API to the PostgreSQL resource
  • Using persistent containers
  • Adding the Storage hosting integration
  • Adding the Keycloak hosting integration
  • Testing the Aspire hosted .NET app
Using production ready defaults 38min
  • Adding resiliency to PostgreSQL connections
  • Using default PostgreSQL health checks
  • Adding Storage resiliency and health check defaults
  • Adding a ServiceDefaults project
  • A few more cleanups
  • Diagnosing issues across dependencies
Azure deployment with Aspire 1hr 2min
  • What is Infrastructure As Code?
  • Adding Azure Postgres Flexible Server support
  • Customizing Azure Storage Infrastructure
  • Customizing Azure Container Apps Infrastructure
  • Adding deployment parameters
  • Excluding resources not needed in the cloud
  • Deploying via the Azure Developer CLI (AZD)
  • Exploring deployed resources
  • Testing the deployed API
Using Bicep & Aspire together 39min
  • What is Bicep?
  • Getting started with Bicep
  • Declaring a Front Door resource with Bicep
  • Using Bicep resources in AppHost
  • Deploying Bicep provisioned Front Door
  • Generating Bicep from the Aspire App Model
Deploying the front-end with Aspire 51min
  • Running the Blazor front-end in .NET Aspire
  • Deploying the Blazor front-end to Azure
  • Running the React front-end in .NET Aspire
  • Deploying the React front-end to Azure
  • Fixing CORS issues
Aspire for .NET Developers

Course Includes

  • 7 Modules, 41 Lessons
  • 5 Hours of Video
  • Full source code
  • Illustrated handouts
  • Course Certificate
Enroll Now

Course 7: Stripe Payments for .NET Developers

Welcome to the course! 5min
  • Course introduction
  • What you'll build in this course
  • What you need to know first
  • Software prerequisites
Getting started with Stripe 9min
  • What is Stripe?
  • Accepting payments with Stripe
  • The Stripe payment flow
  • Creating a Stripe account
Creating checkout sessions 54min
  • Running the initial backend
  • Configuring the API Key
  • Registering Stripe services
  • Add the CheckoutSession response DTO
  • Add the CreateCheckoutSession endpoint
  • Testing checkout session creation
Creating orders 1hr 8min
  • Adding the Orders data models
  • Configuring Orders in the DbContext
  • Adding the Basket Items Provider
  • Implementing the Order Creator
  • Creating orders for the checkout session
  • Trying out order creation
  • Implementing the Get Order endpoint
  • Implementing the Get Orders endpoint
Collecting payment information 59min
  • Configuring the checkout return url
  • Blazor: Collecting payment info
  • Blazor: How it works
  • React: Collecting payment info
  • React: How it works
  • Configuring payment methods
Processing payments with webhooks 30min
  • What is a Webhook?
  • Implementing the Stripe webhook
  • Listening to and forwarding Stripe events
  • Triggering Stripe events
Implementing an Aspire Hosting Integration 45min
  • Implementing the Stripe CLI Resource
  • Adding the AddStripeCli extension
  • Adding the WithWebhookEventListener extension
  • Adding the WithReference extension
  • Adding the WithPrintSecret extension
Using Transactions 41min
  • What is a transaction?
  • Confirming the Order payment (part 1)
  • Confirming the Order payment (part 2)
  • Clearing the shopping basket
  • Adding transaction support
  • Using execution strategies
Idempotency 40min
  • Understanding idempotency
  • Checkout sessions without idempotency
  • Requiring an idempotency key
  • Adding the idempotency key to the data model
  • Making order creation idempotent
  • Making idempotent Stripe calls
Publishing Messages to Queues 34min
  • Handling long-running webhook operations
  • Adding Service Bus to the App Model
  • Registering the Service Bus client
  • Implementing a Service Bus message publisher
  • Publishing events to Service Bus
The Outbox Pattern 34min
  • Introduction to the outbox pattern
  • Adding outbox messages to the data model
  • Storing messages in the outbox table
  • Refactoring the message publisher
  • Adding the Outbox Processor
  • Trying out the outbox pattern
Consuming messages from queues 1hr 18min
  • Refactoring the data model
  • Adding the Worker project
  • Implementing a queue processor
  • Implementing a message handler
  • Using the message handler
  • Trying out the queue processor
  • Handling the Dead Letter Queue
  • The checkout experience end-to-end
Stripe Payments on Azure 52min
  • Storing Stripe secrets on Key Vault
  • Deploying the backend
  • Adding the Azure event destination
  • Deploying the Blazor frontend
  • Deploying the React frontend
Stripe Payments for .NET Developers

Course Includes

  • 13 Modules, 72 Lessons
  • 9 Hours of Video
  • Full source code
  • Illustrated handouts
  • Course Certificate
Enroll Now

4 Bonus Courses Included

Because writing code is only half the job. Master the operational skills required to test, ship, and monitor your systems in the real world.

Bonus courses included with the bootcamp
Integration Testing

Integration Testing for .NET Developers

  • Test Real Database Operations: Use Test Containers to run integration tests against actual PostgreSQL and other databases without complex setup.
  • Mock Authentication & External Services: Configure fake authentication and use NSubstitute to mock external APIs for isolated testing.
  • Test Workers & Message Queues: Verify background workers and Service Bus integration with realistic test scenarios using AutoFixture for test data generation.
CI/CD with Azure DevOps

Azure DevOps CI/CD for .NET Developers

  • Build & Deploy Pipelines: Create automated CI/CD pipelines in Azure DevOps that build, test, and deploy your .NET applications on every commit.
  • Speed Up Pipeline Performance: Enable parallel jobs and parallelize test execution to dramatically reduce build times and get faster feedback.
  • Master Pipeline Configuration: Understand YAML pipeline structure, add custom build and test steps, and generate production-ready pipelines from scratch.
Observability

Troubleshooting .NET Apps in Azure

  • Monitor with Azure Application Insights: Set up comprehensive monitoring for your .NET applications with metrics, performance data, and error tracking.
  • Trace Requests End-to-End: Use distributed tracing to follow requests through your application components and identify bottlenecks and failures.
  • Debug Production Issues Fast: Learn to analyze logs, metrics, and traces to quickly diagnose and resolve real-world performance problems.
✦ Brand-New Course
Microservices for .NET Developers

Microservices for .NET Developers

Full source code included. Video lessons available July 2026.

  • Break the Monolith Into Services: Split the Game Store app into independent Catalog, Basket, Ordering, Payments, and Notifications services, each with its own database, behind a YARP API gateway.
  • Connect Services Sync and Async: Call services with typed clients, service discovery, and resilience, then decouple them with events over Kafka.
  • Coordinate a Distributed Workflow: Build a custom ordering saga over Azure Service Bus with a refund path, then deploy the whole system to Azure.

Included with every course

Course video player
Illustrated course handouts
Signature Online Video Training

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 at any time.

Full Source Code

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

Full English captions

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

certificate
Course Certificate

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

Enroll Now
The bootcamp teaching method

A New Way To Learn

  1. Learn only 1 new concept via clear diagrams and engaging animations.
  2. Get a quick win by building a Minimal Viable Product to apply the concept you just learned.
  3. Discover the limitations and challenges. Face obstacles just like on the job.
  4. Refactor your solution, understanding not only how but why.
  5. Repeat the process with just 1 new concept.

Who Is This Bootcamp For?

  • C# developers with little or no experience in backend web development.
  • Developers who can already build basic APIs but want to add real authentication, cloud deployment, and production-grade architecture.
  • .NET Framework, WPF, or Windows Forms developers moving into modern backend and cloud development.
  • C#/.NET developers who need to get into modern cloud development with Microsoft Azure.

What Students Say About The Bootcamp

Get Started Today!

.NET DEVELOPER BOOTCAMP
11 courses · 45+ hours of video
Full source code · Illustrated handouts · Course certificates
All 11 bootcamp courses included
$ 497
 
Enroll Now
One-time payment · Lifetime access

Meet Your Instructor

Julio Casal, 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.

Start your path to a high-paying job

Average Senior .NET Developer salary in the United States

FAQs

When does the program start and finish?

The .NET Developer Bootcamp is a completely self-paced online program. You decide when you start and when you finish.

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

45+ hours.

What version of .NET is used in this bootcamp?

All bootcamp courses use .NET 10 and Aspire 13.

Will there be more courses added to this bootcamp?

The bootcamp includes all 7 main courses plus 4 bonus courses, including the new Microservices for .NET Developers course at no extra cost. This is the complete and final lineup, so no additional courses will be added.

Do you offer a certification on course completion?

Yes, you will get a certificate at no additional cost after completing all lessons on each course.

How long will I have access to the content?

Your enrollment includes unlimited lifetime access.

I have more questions!

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

Enroll Now
footer-frame

Copyright © 2026 Julio Casal LLC