Azure Bicep From Scratch: The Full Free Series, Labs and Resources
All right, so I have been putting out the Bicep From Scratch series on YouTube over the last few months, and the one thing I keep hearing is that people want it in one place. Fair enough. This page is that place.
Every episode is here in order, with the practice lab that goes with it, the written version if you prefer reading, and the official Microsoft documentation for when you need the real reference instead of my summary of it. Nothing here costs anything.
If you are completely new to infrastructure as code, start at Episode 01 and work down. If you already write Bicep and you are here for a specific thing, use the list below to jump straight to it.
The series at a glance
| Episode | What it covers | Length |
|---|---|---|
| 01 | What Bicep is, why it replaced ARM JSON, and when to use it | 8:05 |
| 02 | Writing and deploying your first template, line by line | 7:59 |
| 03 | Parameters, variables, and .bicepparam files | 14:06 |
| 04 | Modules, and how to stop copy-pasting infrastructure code | 12:59 |
| 05 | Loops, and previewing changes with what-if before you deploy | 14:45 |
| Bonus | Deploying a full Azure environment from a single file | 10:22 |
| Bonus | Why Bicep deployment errors are so hard to read | 5:54 |
Episode 01: What Bicep actually is
This is the orientation episode. Bicep is a domain-specific language that compiles down to ARM JSON, which means everything you deploy with it is still an ARM deployment underneath. Understanding that relationship is what stops Bicep from feeling like magic.
What you'll learn
- What Bicep is and what problem it was built to solve
- How Bicep compiles to ARM JSON, and why that matters for troubleshooting
- Where Bicep fits against Terraform and the portal
- What you need installed before you can deploy anything
Practice it: Introduction to Azure Bicep: Write and Deploy Your First Template is Beginner level and takes about 45 minutes.
Read the written version: What Is Azure Bicep and Why You Should Learn It
Official docs
Episode 02: Your first template, line by line
No skipping ahead in this one. We write a template from an empty file and go through every line, because the syntax only stops looking strange once you have typed it yourself a few times.
What you'll learn
- The anatomy of a resource declaration, and what each part is doing
- How API versions work and why pinning them matters
- Deploying with
az deployment group create - Reading what Azure sends back when the deployment finishes
Practice it: Deploy a Virtual Network and Virtual Machine Using Bicep is Beginner level and takes about 60 minutes.
Read the written version: How to Write Your First Azure Bicep Template
Official docs
Episode 03: Parameters and .bicepparam files
This is where a template stops being a one-off script and starts being something you can reuse across dev, test and production. The .bicepparam format is newer than most of the tutorials you will find, so this episode is worth watching even if you already pass parameters inline.
What you'll learn
- Parameters, variables and outputs, and when to reach for each one
- Writing
.bicepparamfiles instead of JSON parameter files - Decorators for defaults, allowed values and validation
- The built-in functions you will actually use day to day
Practice it: Azure Bicep Expressions: Parameters, Variables, Outputs and Functions is Beginner level and takes about 45 minutes.
Read the written version: Azure Bicep Parameters, Variables, and Conditions
Official docs
Episode 04: Modules
Honestly, this is the episode that changes how your repository looks. Once you can write a module, the copy-pasted 400-line template you have been maintaining turns into something much smaller that you can actually reason about.
What you'll learn
- Splitting a template into modules and wiring them together
- Passing values between modules, and getting outputs back out
- Publishing modules to a private registry backed by Azure Container Registry
- Versioning modules so a change does not break every consumer at once
Practice it: Publish and Consume Bicep Modules with Azure Container Registry is Advanced level and takes about 60 minutes.
Read the written version: Bicep Modules and the Private Registry: Stop Copy-Pasting Templates
Official docs
Episode 05: Loops and what-if
And here's the thing about what-if: it is the closest Bicep gets to terraform plan, and a lot of people never turn it on. If you take one habit away from this whole series, make it this one.
What you'll learn
- Loops for deploying several copies of a resource without repeating yourself
- Conditions, so a resource only deploys in the environments that need it
- Running
az deployment group what-ifto preview a change - Reading what-if output, including where it is known to be noisy
Practice it: Azure Bicep Conditions, Loops and What-If Deployments is Intermediate level and takes about 60 minutes.
Read the written version: Testing Bicep Before It Breaks Production: What-If, PSRule and CI Validation
Official docs
Bonus: A full environment in one file
This one predates the numbered series, but it is the payoff episode. Networking, a web app, storage and the wiring between them, all deployed from a single template.
Practice it: Deploy a Full Azure Environment Using Bicep Infrastructure as Code is Intermediate level and takes about 60 minutes.
Bonus: When the error message makes no sense
Bicep errors surface from the ARM layer underneath, which is why they so often point at a line number that has nothing to do with your actual mistake. This is a short one on how to trace an error back to its real cause.
Official docs
Going further than the series
These are the posts that pick up where the videos stop. They assume you can already write and deploy a template.
- Azure Verified Modules: The New Standard for Bicep in Production covers the module library Microsoft now maintains, so you are not writing every module yourself.
- Bicep vs Terraform on Azure: An Honest Comparison After Building Both is the comparison I get asked for most, written after shipping real work in both.
- Testing Bicep Before It Breaks Production goes deeper than Episode 05 on PSRule and wiring validation into CI.
- Bicep Modules and the Private Registry is the long-form version of Episode 04.
The full lab track
Every lab below runs in a real Azure subscription that is provisioned for you, so there is nothing to set up and no bill at the end. This is the order I would work through them.
Bicep
| Lab | Level | Time |
|---|---|---|
| Introduction to Azure Bicep: Write and Deploy Your First Template | Beginner | 45 min |
| Deploy a Virtual Network and Virtual Machine Using Bicep | Beginner | 60 min |
| Azure Bicep Expressions: Parameters, Variables, Outputs and Functions | Beginner | 45 min |
| Azure Bicep Conditions, Loops and What-If Deployments | Intermediate | 60 min |
| Deploy a Full Azure Environment Using Bicep Infrastructure as Code | Intermediate | 60 min |
| Automate Bicep Deployments with GitHub Actions CI/CD Pipeline | Intermediate | 60 min |
| Publish and Consume Bicep Modules with Azure Container Registry | Advanced | 60 min |
| Azure Deployment Stacks with Bicep for Resource Lifecycle Management | Advanced | 60 min |
ARM templates
You do not need these to learn Bicep. They are here because most people inherit an ARM estate before they get to build a Bicep one, and being able to read the JSON is what makes decompiling it bearable.
| Lab | Level | Time |
|---|---|---|
| Deploying Your First ARM Template | Beginner | 60 min |
| Deploy an Azure Web App using an ARM Template | Beginner | 60 min |
| Deploy a Storage Account with ARM Templates | Intermediate | 45 min |
Pro tip: If you already have ARM JSON in a repository, run
az bicep decompile --file template.jsonon it. The output is never production-ready, but reading the Bicep it generates alongside the JSON you already understand is a fast way to learn the syntax.
Reference material worth bookmarking
- Bicep documentation is the main landing page for everything official.
- Fundamentals of Bicep is the free Microsoft Learn path, and it pairs well with this series.
- ARM template reference has every resource type, every property and every API version. You will use this constantly.
- Bicep Playground lets you write Bicep in the browser and see the compiled ARM JSON side by side.
- Azure Verified Modules is the Microsoft-maintained module library, and it is where you should look before writing a module yourself.
- Decompiling ARM templates to Bicep covers the migration path off JSON.
- Bicep on GitHub is where the language is developed, and the issues list is genuinely useful when something behaves strangely.
Where to start
If you have never written a line of Bicep, watch Episode 01, then do the intro lab before you watch Episode 02. The episodes are short on purpose, and the labs are where the learning actually sticks.
If you are already deploying Bicep and you want to level up, skip to Episode 04 on modules and then read the Azure Verified Modules post. That combination is the difference between templates that work and templates a team can maintain.
New episodes get added here as they publish, so this page is worth bookmarking rather than saving any single video.
