Every cloud journey starts the same way. Someone creates a subscription, deploys the first application by hand, and it works. Then a second team arrives. Then a third.
A year later, the same company usually has:
- resources in regions nobody approved,
- resource groups nobody owns, and a bill nobody can explain,
- virtual networks with overlapping address ranges that can never be connected,
- a database with a public IP "just for testing",
- and a monthly cost that grows faster than the business.
None of these is a disaster on its own. Together, they make every change slow and risky, because everything is already in production.
After more than 20 years in infrastructure, including scaling cloud platforms for a global e-commerce company, I've learned that the cheapest moment to fix these problems is before the first workload lands. That is what a landing zone is for.
In this article I'll walk through how to build one with Terraform, the decisions behind each part, and the mistakes it protects you from. All the code is open source:
👉 github.com/diogosmoreira84/azure-enterprise-landing-zone
What is a landing zone, really?
A landing zone is the pre-built environment that workloads "land" in. When a new team arrives, the hierarchy, the rules, the network, the logging and the cost controls are already there. Teams move fast; the platform team keeps control.
Microsoft's Cloud Adoption Framework describes it through eight design areas. You don't need all of them on day one. The reference I built covers the six that matter most for getting started, and leaves identity and billing for later:
| Design area | Covered | How |
|---|---|---|
| Billing and Entra tenant | Decided once per organisation, outside Terraform | |
| Identity and access | A topic for its own article | |
| Resource organisation | ✅ | Management groups, naming and tagging |
| Network topology | ✅ | Hub and spoke, NSGs, optional firewall, private DNS |
| Security | ✅ | Deny-by-default NSGs, no public IPs in Corp |
| Management | ✅ | Central Log Analytics and Activity Log export |
| Governance | ✅ | Azure Policy guardrails and budgets |
| Platform automation | ✅ | Modular Terraform, remote state, CI with security scanning |
Let's go through them in the order I'd build them.
Step 1: Organise with management groups
Management groups are folders above subscriptions. Anything you assign to a management group, like a policy or a role, is inherited by every subscription below it. Get the hierarchy right and you configure governance once, instead of once per subscription.
The mistake it saves you from: building the hierarchy around the org chart. Departments change at every reorganisation. "Internal" versus "internet-facing" doesn't. Organise by the rules a workload needs, keep it shallow (three or four levels), and always have a place for the exceptions, so nobody has to bend the production rules.
Step 2: Guardrails with Azure Policy
A guideline is something people forget. A policy is something the platform enforces. I start with three guardrails:
| Policy | Where | Why |
|---|---|---|
| Allowed locations | Organisation root | Data residency and a predictable footprint |
| Required tags on resource groups | Organisation root | Every cost and every incident has an owner |
| No public IPs on network interfaces | Corp | Internal stays internal |
In Terraform, I look up built-in policies by name instead of hard-coding GUIDs, which keeps the code readable:
data "azurerm_policy_definition_built_in" "allowed_locations" { display_name = "Allowed locations" } resource "azurerm_management_group_policy_assignment" "allowed_locations" { name = "allowed-locations" management_group_id = var.root_management_group_id policy_definition_id = data.azurerm_policy_definition_built_in.allowed_locations.id parameters = jsonencode({ listOfAllowedLocations = { value = var.allowed_locations } }) } The mistake it saves you from: switching straight to "deny" in an existing environment. You will break deployments on a Friday afternoon. In brownfield subscriptions, start with audit, fix what you find, then enforce.
Step 3: One place for logs
When something breaks, or an auditor asks who changed a firewall rule, the answer must be in one place. The landing zone creates a central Log Analytics workspace and sends the subscription Activity Log to it from day one.
The mistake it saves you from: discovering, during an incident review, that the Activity Log you needed is older than the 90 days Azure keeps by default.
Step 4: A network you won't have to rebuild
The landing zone uses a hub-and-spoke topology. Shared network services live in a central hub. Every workload gets its own spoke, peered to the hub.
Each spoke gets its own subnets, a deny-by-default NSG on every subnet, and, when the firewall is on, a route that sends all outbound traffic through the hub.
A few lessons I'd tattoo on every platform team:
- Plan the address space once, for the whole company. Overlapping ranges are the one networking mistake you cannot fix without rebuilding. In the code, the hub subnets are calculated from a single range with
cidrsubnet(), so there's no manual subnet maths to get wrong. - Reserve the special subnets on day one. Firewall, Gateway and Bastion need exact names and minimum sizes.
- Peering is not transitive. Spoke A can't reach spoke B through the hub unless something routes the traffic. That's the firewall's job.
- Make expensive things optional. Azure Firewall has a significant fixed monthly cost, so it's one variable away, but off by default.
And adding a new workload is data, not code:
spokes = { payments = { address_space = "10.20.0.0/16" subnets = { api = "10.20.1.0/24", db = "10.20.2.0/24" } } } Step 5: Costs under control from day one
Cost is a design area like any other. Three things go a long way:
- Standard tags on everything, enforced by policy, so every euro can be traced to a team. Optional tags are missing within weeks.
- A monthly budget with alerts at 50%, 80% and 100%.
- A forecast alert, which is the one that actually helps: an alert at 100% of actual spend tells you about money that's already gone.
Step 6: Treat the platform like a product
A landing zone isn't a one-off project. It's a product the platform team runs and evolves, so it deserves the same engineering discipline:
- Remote state in a hardened storage account: TLS 1.2, no public blobs, shared keys disabled (Entra ID only), versioning and soft delete. The repository includes a small
bootstrap/to create it. - One module per responsibility: governance, logging, connectivity, cost.
- Validation on inputs that can be wrong, like CIDR ranges and naming prefixes.
- CI on every pull request:
terraform fmt,validate, TFLint and a Checkov security scan. Every skipped security check is skipped on purpose, with the reason written next to the resource.
What a production landing zone adds
This reference shows the patterns. For a real company, you'd add identity (Entra ID groups mapped to roles, Privileged Identity Management, break-glass accounts), subscription vending so every workload gets its own subscription, separate platform subscriptions, Microsoft Defender for Cloud, and hybrid connectivity. For large estates, Microsoft's own Azure Landing Zones Terraform modules are a solid, supported baseline.
But the principles stay the same, and they are the part that matters: decide the rules before the workloads arrive, enforce them in code, and make the right thing the easy thing.
Key takeaways
- Build the foundations before the first workload lands. Fixing them later means changing things that are already in production.
- Organise by the rules workloads need, not by the org chart, and keep the hierarchy shallow.
- Enforce, don't recommend. Policies, tags and budgets only work when the platform applies them.
- Plan the network once. Overlapping address ranges are the mistake you can't undo.
- Run the landing zone like a product, with code review, CI and security scanning.
Try it
The full code, with a step-by-step guide, is here:
👉 github.com/diogosmoreira84/azure-enterprise-landing-zone
With the default settings it costs very little to run, so you can deploy it in a personal subscription and explore.
In the next articles of this series I'll go deeper into each area, starting with Azure Policy: how to roll out guardrails without breaking production.
What was the first thing that went wrong in your cloud environment because the foundations weren't there? I'd love to hear it in the comments.


