Skip to content

Independent marketplace for verified cloud accounts

Separate Cloud Accounts per Environment

Tags and naming conventions do not stop a mistake in staging from reaching production. This guide explains what an account boundary buys you and how to split without doubling your workload.

Nearly every team starts with one account. Development, staging and production share it, separated by naming conventions and good intentions, and for a while that works perfectly well. The arrangement fails in a particular way: not gradually, but on one specific afternoon when a script written for staging runs against production because the credential it picked up could reach both.

The fix is structural. An account boundary is the only separation a cloud platform enforces absolutely, and it is cheap to adopt early and expensive to retrofit late.

Tags and naming are not isolation

Conventions depend on everyone, every time, including the person debugging at midnight and the automation written in a hurry. A tag does not prevent an action; it only labels one after the fact.

Concretely, within a single account a credential scoped to development resources can usually reach production ones unless somebody wrote a policy preventing it, and that policy has to be maintained against every new resource type. A resource quota is consumed account-wide, so a runaway test job exhausts the capacity production needs. A service limit hit by a load test applies to everything. One compromised credential exposes the whole estate. And the audit log mixes all environments together, so investigating a production event means filtering through development noise.

None of this is an argument against tags. Tag everything, because tags are how you attribute cost and find resources. Just do not mistake a label for a wall.

What the boundary actually gives you

Separate accounts convert several policy problems into structural ones.

Access becomes default-deny across the boundary. An identity in the development account has no path to production unless someone deliberately creates one, and creating it is a visible, reviewable act rather than an omission.

Quotas and limits become independent, so a test that consumes every available address or exhausts an API rate limit affects only the environment that ran it.

Blast radius shrinks. A compromise, a misconfigured deletion script or a runaway cost event is confined to one account. This is the same reasoning developed in why account isolation beats one shared account, applied to environments rather than clients.

Cost attribution becomes exact without any tagging discipline at all, because the invoice is already split. For many teams this alone justifies the change, since it finally answers how much the non-production estate costs.

Compliance scope narrows. If regulated data lives only in production, auditors can often scope out the other accounts entirely, which reduces the surface being assessed and the amount of evidence you have to produce.

Which accounts to create

Three is the usual starting point, but the useful list is longer than people expect.

Development is where engineers work, with permissive access and tolerance for breakage. Staging mirrors production in configuration but not necessarily in scale, with access restricted similarly to production so that it genuinely tests the deployment path. Production is tightly controlled, with human write access as the exception.

Three more are worth considering once the first three exist. A logging account that receives audit records from everywhere and allows writes but not deletes, which is what makes the protections in audit logging and activity monitoring from day one meaningful. A shared services account for artefacts, container registries and internal tooling used by all environments. And a backup account holding copies that production identities cannot delete, which is the difference between a recoverable incident and a total one.

Resist creating an account per team on top of this. Environment is the boundary that maps to risk; team is a boundary that maps to org charts, and org charts change.

Billing across several accounts

The first objection is usually billing, and it is less of a problem than it looks.

Most larger providers support a billing organisation where several accounts roll up to one payment method and one invoice, with per-account breakdown underneath. Any volume discount is typically calculated across the group, so splitting does not cost you a tier. Set a separate spend alert on each account, since that is where the detection value sits, and the thresholds for a development account should be far tighter than production.

Providers without an organisation feature mean genuinely separate invoices and separate payment methods, which is administrative overhead rather than extra cost. Decide whether that matters to your finance process before choosing the provider, because discovering it after you have split is an awkward conversation.

Keeping configuration consistent

The real cost of multiple accounts is drift. Three accounts configured by hand become three different environments within a quarter, and the whole point of staging evaporates.

Define infrastructure as code with the account as a parameter, so the same definition produces each environment and the differences are explicit values rather than accidents. Keep environment-specific variation to a short, visible list: instance sizes, replica counts, domain names, and feature switches. If the list grows long, staging has stopped predicting production.

Baseline settings should be applied identically everywhere by automation rather than by memory: logging configuration, password and factor policy, default encryption, network layout and region selection. Apply them at account creation so a new account is never in an unconfigured state. The approach is set out in the infrastructure as code provider model.

Access across the boundary

People still need to work across accounts, and the mechanism you choose determines whether the boundary survives.

Do not create a separate login per person per account. Multiple credential sets lead to shared passwords, skipped second factors and credentials stored in files. Instead, give each person one identity in a single place and let them assume a role in the target account, receiving short-lived credentials for the session. That keeps authentication in one location while authorisation stays per account, and it makes removing someone a single action.

Grade the roles by environment. Broad rights in development, narrower in staging, and read-only by default in production with a deliberate elevation step for changes. Log every role assumption and alert on elevation into production outside normal hours. The underlying model is explained in IAM fundamentals covering users, roles and least privilege.

Automation gets the same treatment. A deployment pipeline assumes a role in the target account rather than holding a long-lived key for it, and the role it assumes in production is narrower than the one it uses in development.

Moving from one account to several

You do not have to migrate everything. The practical path is to leave the existing account as production and build outward.

Start by creating the new accounts and applying the baseline configuration. Then stand up development in its own account first, since it is the lowest risk and shakes out the access model. Move staging next, which is where you discover every hardcoded reference and shared resource. Leave production where it is unless there is a strong reason to move it, because migrating a live environment is a project in its own right.

Expect to find things that cross the boundary: a shared database, a container registry only one account can reach, a secret used everywhere, a DNS zone owned by whichever environment happened to create it. Each needs a decision about which account owns it and how the others reach it. These discoveries are the main work, and finding them is itself an argument for doing the split.

Where the migration involves moving data or workloads rather than only configuration, treat it as a migration project with a cutover plan and a rollback, not as a configuration change you do on a Friday.

When one account is enough

This is not universal advice. A single developer running one small application, a short-lived prototype, or a workload with no sensitive data and no customers does not need five accounts and the overhead that comes with them.

The signals that it is time to split are specific: more than a couple of people with write access, any data you would have to notify someone about losing, a customer-facing service with availability expectations, a compliance obligation, or the first time something in development affects something in production. If any of those apply, the structure pays for itself.

How easy this is depends on the provider. Platforms with a native organisation feature let you create accounts programmatically, apply policy from above and consolidate billing without friction. Others require signing up separately for each account and managing them independently, which is workable but manual. The AWS vs Google Cloud comparison covers how the two approach multi-account structure, and listings such as Buy AWS Account and Buy Digital Ocean Account cover the common starting points. If you have questions about how multiple accounts are delivered and verified, our frequently asked questions page sets out the process.

Related comparisons

Linode vs OVH
vs

Linode vs OVH

Linode is a developer focused compute platform; OVHcloud is a vertically integrated European operator that builds its own servers and…

Hetzner vs Digital Ocean
vs

Hetzner vs Digital Ocean

Hetzner sells hardware value from a mostly European footprint. DigitalOcean sells a developer platform with managed add-ons and deep documentation.…

Google Cloud vs Vultr
vs

Google Cloud vs Vultr

Both platforms will rent you a GPU, and that is where the similarity ends. Vultr gives you the hardware; Google…

Google Cloud vs Azure
vs

Google Cloud vs Azure

Google Cloud and Microsoft Azure both cover the full hyperscaler surface, but identity, data tooling and commercial structure pull teams…

Keep reading

Developer-First Clouds: Simplicity as a Feature
Provider Guides 7 min read

Developer-First Clouds: Simplicity as a Feature

Smaller cloud providers are described by what they lack, but the restraint is the product. What simplicity buys you, and the specific…

Need the account, not just the theory?

Browse documented configurations across every provider in the catalog, or ask us which one fits your workload.

Telegram