BlogCloud and DevOps

Cloud management for growing teams: governance, cost, uptime

Between one shared account and a full platform team, a growing company needs a short list of controls: separate accounts per environment, single sign-on with least privilege, infrastructure as code, one deployment pipeline, alerts tied to what users experience, restores that have been tested, and a bill somebody owns. Put them in place in stages, starting with identity and backups.

What cloud management means at this stage

Cloud management is the set of decisions about who can change what, how changes reach production, how you find out something is broken, how you get data back, and who answers for the bill. At five engineers these decisions are implicit: everyone has admin rights and the person who set things up remembers how they work. Somewhere between ten and fifty engineers that stops being true, and the discovery usually comes through an incident, an audit questionnaire or an invoice.

The cloud providers publish their own guidance. The AWS Well-Architected Framework has six pillars: operational excellence, security, reliability, performance efficiency, cost optimisation and sustainability. The Azure Well-Architected Framework has the first five. Google Cloud’s version has six, with security widened to cover privacy and compliance. They agree on nearly everything and are worth reading. They are also written for every size of organisation at once, and a team of twenty needs to know which parts to do first.

Keep one example in mind throughout: a 25-person software company with a single cloud account, three engineers who all have administrator access, deployments run from a laptop, and a monthly bill that has doubled in two quarters without anyone being able to say why.

Accounts, identity and a security baseline

Separate environments with hard boundaries

Start with structure, because everything else hangs off it. AWS’s guidance on organising your environment with multiple accounts recommends several accounts over one even in the early stages, because an account is an isolation boundary: nothing crosses it unless you allow it. Azure subscriptions under management groups and Google Cloud projects under folders play the same role.

For our 25-person company, four are enough: production, non-production, a security account holding audit logs that nobody can edit, and a management account used only for billing and organisation settings. Resist the reference architectures with thirty accounts. Add more when a team or a compliance scope needs its own.

Identity and least privilege

In our experience, cloud incidents start with a credential far more often than with a clever exploit. The baseline:

  • People sign in through your identity provider with single sign-on and multi-factor authentication, preferably passkeys or security keys. No shared logins.
  • Nobody holds long-lived access keys. People get temporary credentials through SSO, workloads get roles, and the CI pipeline authenticates with short-lived tokens through OIDC federation instead of a stored secret.
  • The root or owner credential is locked away with its own MFA and used for almost nothing.
  • Day-to-day access to production is read-only. Changes go through the pipeline. Elevated access exists, is time-limited and is logged.

Least privilege is a direction, not a starting point. Begin with the provider’s managed roles, then tighten using the access-analysis tools that show which permissions were actually used. Trying to write perfect policies on day one stalls everything.

The rest of the baseline

Turn on the organisation-wide audit log and send it to the security account. Block public storage buckets by default. Encrypt storage and databases, which is now a tick-box. Keep secrets in the secrets manager, not in environment files. Switch on the provider’s posture tool (AWS Security Hub, Microsoft Defender for Cloud or Google’s Security Command Center) and treat its high-severity findings as bugs. None of this needs a security team. It needs a few days and an owner.

Infrastructure as code and one path to production

If your infrastructure exists only as clicks in a console, you cannot review a change, repeat it in another environment or rebuild after a disaster. Infrastructure as code fixes all three. Use Terraform, its open-source fork OpenTofu, Pulumi or the provider’s own tool. The choice matters less than the discipline:

  • State is stored remotely with locking, never on a laptop.
  • Every change is a pull request that shows the plan before it is applied.
  • Production is not changed by hand. If someone must, the change is written back into code the same day.

You do not have to import everything at once. Put new resources in code from today, then bring in the existing ones in order of how much it would hurt to lose them: network and identity first, databases next.

The same thinking applies to application delivery. Aim for one pipeline that builds an artefact once and promotes that same artefact through non-production to production, with automated tests, a database migration step and a rollback that has been tried. Our example company’s laptop deployments are a risk, and they also mean nobody is sure what is running. The delivery metrics from the DORA research programme, such as change lead time, deployment frequency and change fail rate, are a good check on whether the pipeline is helping.

Observability, on-call and tested recovery

Know what healthy means

Pick two or three things users actually do, such as signing in, loading the dashboard or completing a payment, and set a target for each: what share of requests should succeed, and how fast. Those are your service level objectives. Google’s SRE practice, where the idea comes from, advises a handful of indicators over a wall of them, and it is right.

Then alert on those and little else. A page at 3am should mean users are affected and a person can do something about it. CPU at 85 per cent is neither. Alert noise is what wears on-call rotas out.

Make on-call humane

Someone has to be reachable. For a small team that means a rota, a paging tool, a short runbook per service that says how to roll back and whom to call, and a written review after each incident that looks for causes without blaming people. If the rota is two people, that is a staffing problem to solve, not a badge of honour.

Restore, do not just back up

Agree two numbers for each data store in plain language: how much data you can afford to lose and how long you can afford to be down. Configure backups to match, copy them to a second account or region so that one compromised credential cannot delete both, and restore one on a schedule.

The AWS reliability guidance puts it bluntly: “the only error recovery that works is the path you test frequently”. A quarterly restore drill, timed, with the result written down, is the minimum. In our experience the first drill usually shows that the backup was fine and the restore procedure was not.

Who owns the bill? Cost visibility and budgets

Our example company’s bill doubled because nobody was looking, which is the usual cause. The FinOps Foundation’s framework describes the work in three phases, Inform, Optimize and Operate, and the order matters. You cannot optimise what you cannot attribute.

Inform first:

  • Tag every resource with owner, environment and service, enforced in the infrastructure code so that untagged resources fail review.
  • Set a budget with alerts on each account, and switch on the provider’s anomaly detection.
  • Hold a fifteen-minute review each week where one named person looks at the biggest movers.

Then optimise the obvious. Switch off non-production environments outside working hours. Delete unattached disks and old snapshots. Right-size the instances that sit almost idle. Set lifecycle rules on storage. Watch the items that surprise people: data transfer between zones and out to the internet, NAT gateways, and log ingestion, which can quietly outgrow the compute it describes.

Buy commitments, such as savings plans or reserved capacity, only once usage has been stable for a few months. They are a discount on a forecast, and an early-stage forecast is a guess.

GPU and model inference spend behaves differently enough to need its own treatment, which we give it in FinOps for AI.

Managed services, platform teams and partners

When do managed services beat running your own?

Almost always, at this size. A managed database, queue or container platform costs more per unit than running it yourself and far less than the engineering hours spent patching, upgrading and being woken by it. Our default is managed for databases, message queues, container runtimes and observability. We revisit only when three things are true together: the service is central to the product, the cost difference is large and measured, and there are enough people to carry the on-call.

Kubernetes deserves a specific mention, because teams adopt it early for the wrong reasons. Managed container services and serverless platforms run most web products with a fraction of the upkeep. Move to Kubernetes when you have many services and several teams that need one deployment model, and use the provider’s managed control plane when you do.

The same trade-off appears in web hosting, which we discuss in Next.js vs Astro, and in analytics, where data engineering choices about the warehouse and pipelines drive most of the cost.

When to add a platform team or a DevOps partner

The signs are consistent. Senior product engineers spend a large part of each week on infrastructure. Teams queue for environments or copy each other’s pipelines. The same incident recurs. An enterprise customer, or an audit such as SOC 2 or ISO 27001, asks for evidence you cannot produce.

A first platform hire or a small team makes sense when that work is continuous. A partner makes sense when it is a project: setting up the account structure and pipelines, a migration, audit preparation, or on-call cover while the team is too small for a fair rota. If you bring one in, keep ownership. The code lives in your repositories, administrator access stays with your staff, and everything is documented well enough that you could change partner.

A staged checklist by company size

The bands are rough. Move to the next stage when the pain arrives, not when the headcount does.

Stage 1: up to about 10 engineers

  1. SSO and MFA for everyone; root credentials locked away.
  2. Production separated from everything else.
  3. Automated database backups, with one restore tested.
  4. A budget alert on the account.
  5. Deployments from a pipeline, not a laptop.
  6. An error tracker and an uptime check that notify a shared channel.

Stage 2: about 10 to 40 engineers

  1. An account structure with production, non-production, security and management.
  2. All new infrastructure in code; existing resources imported in order of risk.
  3. No long-lived keys; CI authenticates through OIDC.
  4. Service level objectives for the main user journeys, with paging tied to them.
  5. An on-call rota, runbooks and written incident reviews.
  6. Mandatory tags and a weekly cost review with a named owner.
  7. Quarterly restore drills; backups copied to a second account.
  8. Central audit logs and the provider’s posture tool, with findings triaged.

Stage 3: about 40 to 150 engineers

  1. A platform owner or team with a published roadmap.
  2. Standard templates for new services, with pipeline, monitoring and permissions included.
  3. Organisation-level guardrails that prevent unsafe configurations, not just report them.
  4. Cost allocated to teams, with commitments bought against stable usage.
  5. Disaster recovery exercised end to end, including rebuilding infrastructure from code.
  6. A yearly review of each important workload against your provider’s well-architected framework.
  7. Evidence collection for audits automated where possible.

Where to start this week

Do three things in the next five working days. Put every person behind single sign-on with MFA and delete the access keys nobody can explain. Restore one production backup into a scratch environment and time it. Set a budget alert at last month’s spend plus a margin.

Then book two hours to write down, for each area in this article, who owns it today. The blank rows are your plan for the quarter. If you would like help with the foundations or a second pair of eyes on the result, this is what our cloud and DevOps team does.

Questions

Asked often.

How many cloud accounts does a small company need?

At least three or four: production, non-production, and separate homes for security logs and billing administration. AWS recommends multiple accounts even at the start, and Azure subscriptions and Google Cloud projects serve the same purpose. The boundary limits the damage from a mistake or a stolen credential and makes costs easier to attribute. Add more only when a team or compliance scope needs isolation.

When should a startup hire a platform or DevOps engineer?

When infrastructure work regularly takes senior product engineers away from the roadmap, when teams wait on each other for environments or deployments, or when an audit or enterprise customer demands evidence of controls. Before that point, managed services and a part-time owner are usually enough.

What is the first thing to fix in a messy cloud account?

Identity. Put everyone behind single sign-on with multi-factor authentication, remove shared logins and long-lived access keys, and lock away the root or owner credentials. Then confirm that backups exist and restore one to prove it works. Those two steps address the most damaging failures: an account takeover and data you cannot get back.

Not on the list? Ask us directly

Keep reading

More notes from the build.

All blogs

Let’s build your stack.

Send a brief and we’ll reply with next steps.