CI/CD for .NET Microservices on Azure

How It Works

You start with a sample .NET 8 microservice and a GitHub repo. Over two sessions you build a real CI/CD pipeline -- commit to running on Azure staging in session 1, then the full production release flow with approval gates and rollback in session 2. You code along on your own machine and deploy into your own Azure subscription. Every step is explained as it is built, and the pipeline is deliberately broken and fixed in session 1 so you learn to troubleshoot the red builds you will actually hit on real projects.

Session Breakdown

Session 1 -- Wed 22 April 2026, 5 PM UK

From commit to running on Azure staging

GitHub Actions, YAML fundamentals, OIDC to Azure, and the troubleshooting muscles you need when the build goes red

After this: every push to main lands on Azure staging. One environment, no approval gate yet, but a complete working pipeline you can demo on Monday.

What you will do

Walk through the sample .NET 8 microservice repo and run it locally so everyone starts from the same baseline
Learn the YAML structure GitHub Actions workflows are built on -- the four things that actually matter (name, on, jobs, steps), indentation rules, and how to read an unfamiliar workflow file and find your way around it
Write a GitHub Actions workflow from scratch: restore, build, test, publish a versioned artifact
Configure triggers so the workflow fires on pushes to main and on pull requests
Wire unit tests in as a build gate -- failing tests break the build, no exceptions
Add a branch protection rule so main cannot be pushed to directly
Wire Azure to GitHub using OIDC federation -- no long-lived secrets, no keys sitting in GitHub settings
Create an Azure App Service and add a deploy step so the artifact lands on staging automatically
Break the pipeline four ways and fix it four ways -- indentation errors, missing credentials, failing tests, failed deploy steps -- and learn exactly where to click in the Actions UI when a build goes red

Why this order: The theory goes exactly where it earns its place. YAML structure comes right before you write your first workflow. Troubleshooting comes after you have something working that can be deliberately broken. No 20-minute lectures upfront -- you type from minute 10.

Session 2 -- 25 April 2026, 5 PM UK

Production-shaped release flow

Deployment slots, approval gates, health checks, and rollback

After this: a full release flow -- commit, build, test, staging, approval, production, health check, rollback.

What you will do

Add a production slot alongside the staging slot on the App Service, and separate environment-specific settings cleanly
Configure a manual approval gate using GitHub Environments with protected reviewers -- nothing reaches production without a human signing off
Promote the same artifact from staging to production -- no rebuild, no drift, same binary that passed tests is the binary that goes live
Add a health check validation step after each deployment so releases fail automatically when the app does not come up cleanly
Walk through a rollback by swapping slots back when a bad release reaches production -- and see why slot swap is the fastest rollback you have

Note: Session 2 assumes the session 1 pipeline is in place. Session 1 stands alone if you only need CI plus a basic staging deploy. Session 2 is not standalone -- it builds directly on session 1.

Pricing

Per Session

4,500

INR

$54.25

USD

£41

GBP

Pay per session. No commitment beyond the session you are joining.

Pay Now

How it works: Pay for the session you want to attend. Session 1 stands alone if you only need CI plus a staging deploy. If you attended Session 1 and want to continue with the production release flow, pay for Session 2 before it starts.

After payment, send your confirmation to me on LinkedIn along with your name, email, and WhatsApp number.

What You Leave With

⚙

A working GitHub Actions pipeline you can lift into any real .NET project on Monday morning

🔑

OIDC federation setup -- no long-lived secrets, no keys to rotate, no credentials to leak

▶

Azure App Service with staging and production slots wired up and deploying automatically from GitHub

✅

A manual approval gate for production promotion, with protected reviewers and health check validation

🚨

A rollback procedure using slot swap -- the fastest recovery path when a release goes wrong

🔍

A "when your pipeline goes red" cheat sheet -- the one-pager you keep next to you every time a build breaks

Tech Stack

Everything used in the workshop is free at the tier you need, widely used in real .NET projects, and reflects what employers are actually shipping with today.

.NET 8

Current LTS runtime

ASP.NET Core

Sample microservice

GitHub Actions

CI/CD workflow engine

YAML

Workflow definition syntax

Azure App Service

Hosting platform -- free tier is sufficient

Deployment Slots

Staging and production isolation

OIDC Federation

Secret-free auth from GitHub to Azure

Azure CLI

Infrastructure setup

GitHub Environments

Approval gates and protected reviewers

xUnit

Testing as a build gate

Prerequisites -- What You Should Already Know

Comfortable with C# and ASP.NET Core -- can build and run a Web API locally
Git basics -- clone, branch, commit, push, pull request
General awareness of what cloud hosting is (you do not need Azure experience)

If you have been handed a pipeline you did not write and are nervous about changing it, this workshop is exactly for you.

Not Required to Know Beforehand

You do not need prior experience with any of the following. They are introduced during the workshop:

GitHub Actions or YAML workflow syntax
Azure App Service, deployment slots, or the Azure Portal
OIDC federation
Branch protection or GitHub Environments

Note on scope: This workshop is focused on the CI/CD fundamentals that the majority of real .NET projects actually need. It is not a deep dive into Kubernetes, Container Apps, service mesh, or advanced release patterns like blue-green or canary. The goal is to get the fundamentals right on a pattern that works for most projects, and leave you with a pipeline you can copy into real work.

What This Workshop Does Not Cover

This is a focused CI/CD workshop. To set clear expectations, it does not cover:

-- An introduction to .NET, C#, or ASP.NET Core

-- Kubernetes, Container Apps, or service mesh deployment patterns

-- Blue-green or canary release strategies (separate topic, separate workshop)

-- Infrastructure as Code tooling (Bicep, Terraform) beyond minimal Azure CLI setup

-- Job search strategy, CV reviews, or mock interviews

-- Guaranteed interview calls, promotions, or role changes

Frequently Asked Questions

Can I attend only session 1?

Yes. Session 1 stands alone as a CI + basic staging deploy workshop. You leave with a working pipeline that lands code on Azure staging on every green push. Session 2 is not standalone though -- it builds directly on the session 1 pipeline.

What if I miss a session?

Recordings are shared with attendees after each session. A starter branch is also provided for session 2 that matches the state session 1 ends on, so you can catch up on your own time and still follow session 2 live.

What if I get stuck during a session?

We pause and fix it in the room. For anything that cannot be resolved live, follow-up support is provided between sessions so you are up and running before the next one.

Will Azure cost me money?

No. The workshop uses Azure free tier resources throughout. App Service F1 tier, free-tier slots, and the standard free Azure account are enough for everything we build. Setup instructions include how to verify you are within the free tier.

Do I need prior Azure experience?

No. If you have a GitHub account and can install the Azure CLI, you have enough to start. The workshop walks through the Azure setup from the first App Service onwards.

Will this help me in interviews?

Senior .NET interviews routinely ask "walk me through your CI/CD pipeline." After this workshop you can describe a real pipeline you built yourself -- with concrete answers on how tests gate the build, how secrets are handled without long-lived keys, how staging and production are separated, and how you roll back a bad release. There are no guarantees -- but candidates who can explain what they built and why tend to do well.

Can I get an invoice for my employer?

Yes. If your employer is sponsoring your participation, reach out to me directly on LinkedIn and I will provide a proper invoice.

Is this a one-time workshop or will there be more cohorts?

This is the founding cohort for the CI/CD workshop. Future cohorts may be announced later depending on demand.

How It Works

Session Breakdown

What you will do

What you will do

Pricing

What You Leave With

Tech Stack

Prerequisites -- What You Should Already Know

Not Required to Know Beforehand

What You Will Need

What This Workshop Does Not Cover

Frequently Asked Questions