Skip to content

Cloud architecture · Security · 7 min read ·

Landing zones before the first workload

The account structure, identity, network and guardrails that every later decision rests on. What a landing zone has to settle, what it can leave open, and the order that avoids rebuilding it in year two.

The first workload in a new cloud estate is never the expensive one. The expensive one is the fortieth, when the account that was "just for the pilot" holds production data, the shared VPC has three overlapping address ranges, and nobody can say which identity has write access to what. A landing zone is the set of decisions you make before that happens. It is not a product you buy, although every vendor sells one; it is a short list of structural choices and the automation that enforces them.

What a landing zone has to settle

Four things, and only four, must be decided before the first workload lands. Everything else can follow.

Where the boundaries are. Accounts, subscriptions or projects are the only isolation boundary that is free, complete and understood by every tool. Use them generously: one per environment per workload family is a sensible default, with separate ones for shared services (networking, logging, identity) and for the organisation's own management. A boundary you did not draw at the start cannot be drawn later without a migration.

Who can do what. Identity federates from one directory; nothing is a local user. Roles are coarse at first (platform admin, workload owner, read-only auditor) and tightened as real usage appears. The rule that matters most is that no human holds standing write access to production; they request it, it is granted for a window, and the grant is logged.

How things talk. Address space is planned for the whole estate on day one, even though most of it is empty. Hub-and-spoke or a transit gateway, private connectivity to the office and to other clouds, DNS that resolves across every boundary, and egress that goes through something you can inspect. Overlapping ranges are the single most common reason an estate needs rebuilding.

What is forbidden. Guardrails that apply to every boundary regardless of who created it: no public storage, encryption on by default, specific regions only, logging that cannot be switched off, and tagging that is required for anything to be created. These are policies enforced by the platform (service control policies, Azure Policy, organisation policy constraints), not conventions enforced by code review.

What it can leave open

A landing zone that tries to decide everything becomes a committee. Deliberately defer:

  • the compute model (containers, functions, VMs), which the workloads will decide;
  • the exact CI/CD tooling, as long as deployment identities are federated and short-lived;
  • cost allocation beyond the tag that names an owner;
  • the observability stack, as long as logs and metrics are exported somewhere central from day one.

The test for each deferred decision is whether changing it later requires moving data or re-addressing a network. If it does not, it can wait.

The order that holds up

  1. Identity and the management boundary first. The directory, the break-glass accounts, the organisation root, and the audit log that records everything from here on.
  2. Guardrails second, applied to the root so every later boundary inherits them. Test them by trying to break them.
  3. Network third, laid out as a plan for the whole address space and built only as far as the first workloads need.
  4. Shared services fourth: central logging, the artifact registry, the secret store, the DNS zones.
  5. The first workload boundary last, created from the same template every later one will use.

Doing the network first, which is the instinct of most infrastructure teams, produces a beautiful topology with no identity model and no guardrails, and the first workload arrives with a long-lived key in a pipeline variable.

Everything as code, including the exceptions

The landing zone is Terraform (or the cloud's native equivalent) applied by a pipeline whose identity is itself federated. A new boundary is a pull request that adds one entry to a list; the pipeline creates the account, attaches the guardrails, peers the network and registers the logging. An exception to a guardrail is also a pull request, with the reason in the description, so the list of exceptions is reviewable and expires.

What should not be code is the break-glass path. Two or three human identities with hardware keys, stored in a sealed envelope or its digital equivalent, able to reach the root when the pipeline, the directory or the network is the thing that is broken. Rehearse it twice a year.

Signs it is working

  • A new workload gets its own boundary, with networking and logging, in under a day and without a ticket to the platform team.
  • Nobody can name a resource that was created outside the pipeline.
  • The security team's questions are answered by querying the organisation, not by asking each team.
  • The second cloud, if there is one, follows the same shape with a different provider module.

Signs it is not

  • Production and non-production share a boundary "temporarily".
  • A spreadsheet lists which engineer has which key.
  • The guardrails live in a wiki page that says "please".
  • The platform team is the bottleneck for every new project, because creating a boundary is a manual runbook.

If the estate already exists and the answers above are uncomfortable, the fix is usually not a rebuild; it is drawing the boundaries that are missing, applying the guardrails to what is there, and moving workloads across one at a time. An architecture review is the usual way to find out which of those three applies.