The idea of an “immutable” Cloud Landing Zone sounds perfect: secure foundations, well-separated accounts/subscriptions, centralized networking, mandatory logging, and guardrails that prevent drift. The problem is that immutability is rarely achieved by design; it gets “negotiated” in day-to-day operations. And that negotiation usually happens when a development team needs to move fast and discovers that the fast path goes under (or over) the guardrails.
I’ve seen landing zones that were technically well built (Control Tower / Azure Landing Zones with policies, auditing, and structure) end up being vulnerable because of operational decisions: “so we don’t block the team,” “to avoid tickets,” “so the pipeline deploys without friction.” The result is not always an immediate breach; it’s usually something quieter: gradual loss of control over identity, accounts, and platform boundaries.
Dangerous belief: “if it’s in the landing zone, it can’t be touched”
In real companies, what breaks “immutability” the most is not an external attacker, but a combination of poorly delegated permissions and automations that assume privilege. The landing zone defines a desired state, but the real state is dictated by: who can create accounts/subscriptions, who can assume admin roles, and who can apply infrastructure at the organizational level.
A typical pattern: it’s defined that the security account (or platform subscription) centralizes logs and controls, but product teams are allowed permissions to “fix” things when their deployment fails. When a pipeline fails because of an SCP/Policy, the incentive is clear: “give me a higher role, then we’ll give it back.” That give-back almost never happens, or it gets requested again in the next sprint.
The business consequence is not usually immediate, but it is cumulative: resources outside standards, new exfiltration paths (for example, logs not sent or disabled), and real difficulty responding to internal audits. The most expensive part comes when massive remediation is needed: reconciling hundreds of accounts/subscriptions with divergent configurations and fuzzy ownership.
How the foundations get “hacked”: two recurring paths (accounts and privileged IaC)
There are two paths that repeat over and over. The first is delegating account creation and management to identities with too many privileges. It’s not uncommon to see near-admin access to account vending processes (Account Factory / internal automations) because “otherwise it takes us days.” The landing zone goes from being a governance framework to being a self-service admin.
The second path is abuse of IaC deployments (CloudFormation/Bicep/Terraform) run from privileged roles. If the CI/CD role can create/update IAM, modify audit roles, or touch organization-level parameters (AWS Organizations / Management Groups), then the pipeline becomes, de facto, a “programmable root.” Even if the intent is good (automation), the risk is structural: any change in the repo, or a poorly reviewed template, can reconfigure guardrails.
- Delegation of account vending with broad permissions: allows creating accounts/subscriptions outside the official path or with the wrong OU/MG.
In practice, this ends up in “orphan” accounts without a logging baseline, without network boundaries, and with local identities that nobody governs. When an incident hits, figuring out who the real owner of that account is and what policies apply becomes a race against time.
- Pipelines with roles that can modify identity and governance: CI/CD that can touch IAM/security roles or organization.
This enables shortcuts like creating a “temporary” role with AdministratorAccess to unblock a deployment, or altering trust policies to allow assumptions from unplanned accounts. No malicious intent is required: pressure and lack of strict reviews are enough.
The important nuance: it’s not the “dev team’s fault.” It’s an operational design failure. If your landing zone depends on people “behaving well,” it’s not a control: it’s an expectation.
From “detective” guardrail to preventive control: what really changes the game
Many organizations stop at detective controls: alerts, Security Hub/Defender findings, periodic audits. That helps, but it arrives too late when what’s broken is the foundation: an overly powerful role, a change in an SCP/Policy, or a pipeline that can now deploy out of bounds.
Preventive controls are not “more bureaucracy”; they are hard limits where they make sense. For example: preventing a deployment role from creating arbitrary IAM policies, or preventing product teams from modifying organizational configurations. The goal is that the fast path still exists, but within a lane. When the lane doesn’t exist, the door opens for the “hack” as the norm.
A frequent corporate anti-pattern is using an automation role with * permissions over * “while the landing zone stabilizes.” That “while” lasts for years. I’ve seen it cause compliance incidents (due to untracked permission changes) and also operational incidents (due to deployments that delete or overwrite shared resources).
- Preventive means “it can’t be done,” not “I find out later”.
If a team can disable logs or bypass enrollment/blueprint, the problem is not that there’s no alert: it’s that the control is not preventive. Prevention reduces the number of incidents and also the mental cost of operating.
- The control must be where it hurts: identity, account vending, and organization.
Most escapes happen in “platform” layers, not in application resources. Blocking creation of privileged identities or changes to trust policies from product pipelines usually has better ROI than chasing resource configurations one by one.
How to do it in practice: operational hardening without blocking teams
The practical way to keep a landing zone “hard to hack” is to clearly separate: who defines the foundations, who operates them, and what a product team can do without touching identity/governance. That means designing roles and boundaries with real flows in mind (incidents, urgent deployments, new accounts), not an ideal diagram.
In AWS, an effective measure is to harden the CI/CD role so it can’t escalate privileges or create new assumption paths. Illustrative example policy (cuts typical surface area):
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DenyIAMPrivilegeEscalation",
"Effect": "Deny",
"Action": [
"iam:CreatePolicy",
"iam:CreatePolicyVersion",
"iam:SetDefaultPolicyVersion",
"iam:AttachRolePolicy",
"iam:AttachUserPolicy",
"iam:PutRolePolicy",
"iam:PutUserPolicy",
"iam:UpdateAssumeRolePolicy",
"iam:PassRole"
],
"Resource": "*"
}
]
}
It’s not a universal recipe (it depends on your deployment model), but it illustrates the point: the pipeline should not be able to invent permissions or modify trust relationships. If you need iam:PassRole for services (for example, ECS/Lambda), limit it to specific ARNs of execution roles, not to *.
Practical validation in AWS (no theory): review in IAM Access Analyzer and CloudTrail whether the pipeline role is performing IAM actions outside what’s expected, and verify that your SCPs (if you use Organizations) deny changes to organizational and audit resources from unauthorized accounts. A useful indicator is to search in CloudTrail for events like UpdateAssumeRolePolicy, AttachRolePolicy and PutRolePolicy originating from CI/CD identities.
In Azure, the operational equivalent is to prevent deployment identities from having high-level permissions (Owner/Contributor at the Management Group or base Subscription level) and to use scoped assignments. If a service principal can assign roles or create role assignments freely, you end up with indirect escalation. Real validation involves reviewing Azure Activity Logs for roleAssignments/write events and policy changes at the Management Group level, correlating it with pipelines.
Recommendations for corporate environments
The myth is not that landing zones are useless; it’s believing that, by existing, they are immutable. In real operations, developers “hack” the foundations when the permissions and automation model leaves them an easy way out and when the organization rewards delivery time over control.
If you want resilient landing zones, the focus isn’t on adding more dashboards, but on making preventive the controls that get abused the most: account/subscription creation, changes in organization (OU/MG), and any CI/CD capability to touch IAM/trust/role assignments. When those boundaries are well set and validated with real traces (CloudTrail/Activity Logs), team speed can coexist with real guardrails.
Interested in Cloud Security?
Technical analysis, hands-on labs and real-world cloud security insights.