Stop Building Apps,
Start Building Production Systems

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: There's a canyon between "Hello World" tutorials and cloud-native, security-focused, scalable 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?

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.
alternative

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.
alternative

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.
  • Leverage ASP.NET Core's Built-In Infrastructure: Skip third-party logging libraries and use the framework's native logging that's already optimized 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.
  • Leverage Built-In HTTP Logging: Use ASP.NET Core's HTTP logging middleware - get 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.
Middleware

Docker Mini Course

  • Run Services Instantly: Run popular services and tools as containers, without complex local installations or configuration.
  • Master Essential Docker Commands: Use volumes, ports, and environment variables for real development workflows.
  • Use Docker Compose for Multi-Service Setups: Orchestrate multiple containers together for complete development environments.
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.
  • Seamless 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) seamlessly after OAuth login - standardized identity claims across any provider.
Start Watching

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
.NET Aspire
.NET 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 - seamless integration with 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.
.NET Aspire dashboard

Debug Performance Issues with .NET Aspire Tracing

  • Debug Performance Issues in Seconds: See exactly where your API calls are slow - database queries, external services, or internal logic - with precise timing data.
  • Trace Requests Across Your Entire System: Follow a single request from your API through all dependencies and services to understand the complete flow.
  • Spot Problems Before Your Users Do: Built-in dashboards reveal bottlenecks, failed dependencies, and performance regressions during development.
Infrastructure as Code

Define Your Entire System in C#

  • Never manually click through Azure portal to set up environments again
  • Build bulletproof deployments that work identically every time
  • Deploy to dev, staging, and production with one command
  • Write infrastructure in C# instead of struggling with YAML or JSON
.NET Aspire dashboard

Map Your Architecture Visually with .NET Aspire

  • Understand Your Architecture at a Glance: See how your API, database, storage, and external services connect - no more guessing about system dependencies.
  • Instantly Spot What's Broken: Green and red indicators show the health of every service in real-time - identify problems before they cascade.
  • Onboard New Developers in Minutes: Visual system maps eliminate confusion about how services interact - new team members understand the system immediately.
Bicep

Advanced Infrastructure-As-Code with Bicep

  • Use Azure's Deployment Language: Learn the native Azure language specifically designed for your infrastructure-as-code solutions in Azure.
  • Access Every Azure Resource: Go beyond Aspire supported Azure resources and configure advanced Azure settings with Bicep.
  • Seamless Aspire Integration: Reference Bicep resources directly in your AppHost project, combining Aspire's built-in resources with custom Bicep files.
Start Watching

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.

alternative
alternative
Blazor

Static Server-Side Rendered (SSR) Application

React

Vite Single Page Application (SPA)

alternative
Two frontend stacks, same user experience

Transform The Way You Build & Ship .NET Systems

Learn how to leverage the latest cloud-native technologies and best practices to build scalable, resilient, and maintainable .NET systems.

alternative
Start Watching

A complete learning path across 5 premium courses

alternative

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 14min
  • 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
  • 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 12min
  • Configuring the front-end
  • Running front-end and back-end together
ASP.NET Core Essentials

Course Includes

  • 9 Modules, 56 Lessons
  • 6.5 Hours of Video
  • Full source code
  • Illustrated handouts
  • Course Certificate
Start Watching

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 9min
  • Configuring the front-end
  • Running front-end and back-end together
ASP.NET Core Advanced

Course Includes

  • 9 Modules, 40 Lessons
  • 4 Hours of Video
  • Full source code
  • Illustrated handouts
  • Course Certificate
Start Watching

Course 3: ASP.NET Core Security

Welcome to the course! 5min
  • Course introduction
  • What this course covers
  • What you need to know first
  • Software prerequisites
Authentication in ASP.NET Core 47min
  • 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 40min
  • 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 7min
  • 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
  • Using resource-based authorization
Working with Docker 51min
  • Introduction to Docker
  • Downloading Docker images
  • Running Docker containers
  • Exposing ports
  • Entering a running container
  • Using volumes
  • Using environment variables
  • Introduction to Docker Compose
  • Using Docker compose
Working with Keycloak 25min
  • Introduction to Keycloak
  • Running Keycloak as a Docker container
  • Creating a realm
  • Creating users
  • Creating and assigning roles
  • Exporting the realm configuration
The OAuth 2.0 framework 51min
  • 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 1min
  • 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 29min
  • 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 39min
  • Configuring the Blazor front-end
  • Running front-end and back-end together
  • The front-end OIDC configuration explained
  • Using the React front-end
ASP.NET Core Security

Course Includes

  • 10 Modules, 64 Lessons
  • 7 Hours of Video
  • Full source code
  • Illustrated handouts
  • Course Certificate
Start Watching

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
Start Watching

Course 5: Containers & .NET Aspire

Welcome to the course! 5min
  • Course introduction
  • What this course covers
  • What you need to know first
  • Software prerequisites
Containerizing .NET Applications 1hr 25min
  • Why containers?
  • Images vs containers
  • How a container image is created
  • Preparing the app for containerization
  • Writing a Dockerfile
  • Building a container image
  • Running a container
  • Talking to a container from Postman
  • Multi-stage builds
  • Image versioning
  • How to create images with the .NET SDK
  • Using dotnet publish to create images
  • Making smaller container images
Publishing to Azure Container Registry 20min
  • Introduction to Azure Container Registry
  • Creating an Azure Container Registry (ACR)
  • 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 the API 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 heath endpoints
.NET Aspire: Modern Local Development 1hr 49min
  • What is .NET Aspire?
  • Using .NET Aspire Integrations
  • Adding the ServiceDefaults project
  • Adding the AppHost project
  • Orchestrating the back-end from AppHost
  • Exploring logs in the Dashboard
  • Adding the Postgres dependency to AppHost
  • Sharing dependency details with the back-end
  • Waiting for dependencies
  • Adding the storage dependency
  • Adding the Keycloak dependency
  • Diagnosing issues across dependencies
.NET Aspire: Infrastructure as Code 1hr 1min
  • 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
.NET Aspire: Using Bicep 40min
  • 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
Front-end deployment with .NET Aspire 52min
  • Running the Blazor frontend in .NET Aspire
  • Deploying the Blazor frontend to Azure
  • Running the React frontend in .NET Aspire
  • Deploying the React frontend to Azure
  • Fixing CORS issues
Containers & .NET Aspire

Course Includes

  • 9 Modules, 61 Lessons
  • 8 Hours of Video
  • Full source code
  • Illustrated handouts
  • Course Certificate
Start Watching

Included with every course

alternative
alternative
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.

Start Watching
alternative

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.
  • .NET Framework, WPF, or Windows Forms developers moving into backend web development with the .NET platform.
  • All C#/.NET developers who need to get into modern cloud development with Microsoft Azure.

What Students Say About The Bootcamp

Choose Your Edition

00
Days
00
Hours
00
Minutes
00
Seconds
COMPLETE EDITION
$ 497
Lifetime Access
$
OFF
Lifetime Access
START WATCHING
alternative
  • ASP.NET Core Essentials
  • ASP.NET Core Advanced
  • ASP.NET Core Security
  • Azure For .NET Developers
  • Containers & .NET Aspire
  • Full source code
  • Full English captions
  • Beautifully illustrated handouts
  • Course certificates
CORE EDITION
$ 247
Lifetime Access
$
OFF
Lifetime Access
START WATCHING
alternative
  • ASP.NET Core Essentials
  • ASP.NET Core Advanced
  • ASP.NET Core Security
  • Full source code
  • Full English captions
  • Beautifully illustrated handouts
  • Course certificates

Meet Your Instructor

alternative

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

alternative

FAQs

When does the program start and finish?

The .NET Cloud 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?

The Core Edition adds up 17.5 hours while the Complete Edition adds up to 34.5 hours.

What version of .NET is used in this bootcamp?

This bootcamp uses .NET 8 since it has Long Term Support (LTS). It will not be updated to .NET 9, given it's a Standard Term Support (STS) release.

Will there be more courses added to this bootcamp?

The Complete Edition includes all currently available courses. If new courses are added in the future, they will be sold separately.

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]

Start Watching
footer-frame

Copyright © 2025 Julio Casal LLC