Everyone starts in the Azure portal. You click Create a resource, fill in a few boxes, and a minute later there's a virtual machine or a storage account humming away. For learning, that's exactly right.
Then you try to do it again.
Maybe a teammate needs the same setup. Maybe you want a "test" copy of "prod". Maybe it's six months later, something's broken, and you're staring at a resource you configured by hand and can't remember. That's where clicking around runs out of road: you can't reliably repeat it, and you can't easily see what you did.
The shift
Infrastructure as Code (IaC) is a simple idea with large consequences. Instead of clicking to create your infrastructure, you describe it in a file, and a tool makes Azure match that description.
Say you want a storage account with certain settings, in a certain region, with certain access rules. You write that down, declaratively, and run a command. The tool works out what needs to change and does it. Run it again and nothing happens, because reality already matches the file. Point it at a fresh subscription and you get an identical environment.
That's the unlock. Your infrastructure becomes:
- Repeatable. The same file produces the same environment, every time.
- Reviewable. Changes go through pull-request review, the same as your app code.
- Versioned. You can see exactly what changed, when, and why.
No more "works on my subscription". No more snowflake environments nobody dares touch.
The tools, without the jargon
You'll hear a few names thrown around. Briefly:
- Bicep. Azure's own IaC language. Clean, Azure-native, a friendly place to start.
- Terraform. The industry standard. It works across clouds, has a huge ecosystem, and a great deal of serious platform work is built on it.
- ARM templates. The original JSON approach. Still around, though Bicep is the nicer face of the same engine.
You don't have to pick perfectly on day one. The mindset carries across all of them: declare the state you want, and let the tool reconcile reality to it.
Why it matters more than it looks
Once your infrastructure is code, everything good about software engineering suddenly applies to it: testing, review, reuse, automation, a full history. Your platform stops being a pile of manual actions and becomes something you can reason about.
That's also where it gets deep, fast. At any real scale, IaC stops being "a file that makes a VM" and becomes the foundation for governance, policy, security guardrails, cost control, and repeatable landing zones for whole organisations. The gap between a working demo and a governed, enterprise-grade platform is enormous, and that gap is exactly where the craft lives. (It's most of what I do for a living.)
But that's a later chapter. If you're just starting out, the on-ramp above is enough to change how you build: stop clicking, start declaring. Pick Bicep or Terraform, define one small thing as code, tear it down, and bring it back. The first time you rebuild an environment from a file in thirty seconds, something clicks, and you won't go back.
Next in the series: the one mental model, "state", that makes Terraform and Bicep suddenly make sense.