Without a platform team, the lowest-effort setup pairs a managed runtime for applications with a hosted IaC run platform for the few cloud resources around them, so nobody maintains state backends, runners, or clusters. The best fit depends on whether most of your infrastructure is application workloads (favor a managed runtime or a workload platform such as Control Plane) or cloud resources like networks, databases, and IAM (favor a hosted IaC platform such as HCP Terraform, Spacelift, env zero, or Pulumi Cloud).
Disclosure: Control Plane publishes this guide.
TL;DR
Three different kinds of products get called “PaaS for infrastructure as code,” and a team without platform engineers usually needs two of them.
- Hosted IaC run platforms (HCP Terraform, Spacelift, env zero, Scalr, Pulumi Cloud) remove state backends and CI runners, but your team still writes and owns every module.
- Developer portals and IDP orchestrators (Backstage, Port, Humanitec) give developers a self-service front end, but someone has to build the templates and the provisioning logic behind them first.
- Managed runtimes (serverless container services and workload platforms) remove most application-layer IaC and shrink what is left to networks, IAM, provider databases, and a few other cloud resources.
- Someone always has to own the modules, templates, or programs behind any portal or UI.
- Control Plane fits as a workload platform for the application layer, with a small Terraform or Pulumi stack for the cloud resources outside it.
What is the best platform as a service for infrastructure as code and provisioning without a platform team?
No single product covers every layer, so the right combination depends on where most of your infrastructure work lives.
| Approach | Examples | What your team writes | What the service runs for you | Guardrails built in | Who still has to own it |
|---|---|---|---|---|---|
| Self-run IaC CLI in CI | Terraform or OpenTofu, Pulumi with a self-managed backend | Code for every resource, CI pipeline config, state backend setup | Nothing beyond what your CI runner executes | None unless you add them | State backend, runner security, credentials, module design, drift detection |
| Hosted IaC run platforms | HCP Terraform, Spacelift, env zero (formerly env0), Scalr | HCL or code for every resource | State storage, plan and apply runs, variable encryption, drift detection on paid tiers | Policy as code (Sentinel or OPA), plan approvals, RBAC | Module design, credentials, resource lifecycle, Day 2 operations |
| Pulumi Cloud | Pulumi Cloud with Pulumi Deployments and Pulumi ESC | TypeScript, Python, Go, C#, or Java programs | State storage, deployments, secrets and environment configuration | Policy as code (Pulumi Policies, formerly CrossGuard), RBAC on paid tiers, ESC environment access controls | Program design, credentials, resource lifecycle, Day 2 operations |
| Developer portals and IDP orchestrators | Backstage Software Templates, Port self-service actions, Humanitec Platform Orchestrator | Templates, actions, or resource definitions that call underlying IaC or APIs | Software catalog, self-service UI, action orchestration | Portal RBAC, approval flows | Every underlying IaC module or API integration, template maintenance, and the portal itself if self-hosted |
| Cloud-native single-cloud tools | AWS CDK with CloudFormation, Azure Bicep | Constructs or Bicep files for every resource | Stack or deployment execution; CloudFormation also tracks state and rolls back failed updates | Stack policies, CloudFormation drift detection, Bicep what-if previews | Construct or module design, IAM, networking, Day 2 operations, one cloud only |
| Serverless container services | Google Cloud Run, Azure Container Apps, Amazon ECS on Fargate | Container images, service configuration, IaC for surrounding resources | Container scheduling and autoscaling; Cloud Run and Container Apps also provide load balancing and TLS on default endpoints, while ECS needs an Application Load Balancer you provision | Service-level IAM, ingress settings | VPCs, databases, DNS, IAM, and the IaC for them |
| Workload platforms | Control Plane | Container images, workload definitions (console, CLI, Terraform or Pulumi provider, or MCP server), IaC for cloud resources outside the platform | Container and VM orchestration across clouds, autoscaling, load balancing, TLS certificates, mTLS, internal firewall, audit trail, observability | Deny-by-default firewall, policy-based access, identity-based secret grants, tamper-proof audit trail | Cloud resources outside the platform (VPCs, provider databases, cloud storage and queue services, account-level IAM) |
Several hosted IaC platforms reduce the “who writes the module” burden with self-service catalogs on paid tiers. HCP Terraform no-code provisioning (Standard and Premium), Spacelift Blueprints (Business and up), and env zero self-service templates let one engineer publish an approved module that others deploy from a form. Port self-service actions and Backstage Software Templates give developers a UI, but someone must wire each one to the provisioning logic behind it. The Humanitec Platform Orchestrator generates resource graphs at deployment time from resource definitions that someone has to write first. The top infrastructure as code tools compares the IaC engines themselves.
Which resources does each approach provision?
Each resource your application needs is provisioned by one layer, and that layer decides how much code your team writes and maintains.
| Resource | Hosted IaC platform | Developer portal | Serverless containers | Workload platform (Control Plane) |
|---|---|---|---|---|
| Application containers | Your team writes IaC for the compute service | A template calls the underlying IaC or API | The service runs containers from your image | A workload definition runs containers in every location of its Control Plane Global Virtual Cloud (GVC), with no cluster to manage |
| Autoscaling and load balancing | Your team writes scaling policies and load balancer resources | A template calls the underlying IaC | Built in for Cloud Run and Container Apps; ECS needs a load balancer in IaC | Built in per workload |
| TLS certificates and domains | Your team writes ACM, managed certificate, or cert-manager resources | A template calls the underlying IaC | Built in for Cloud Run and Container Apps default endpoints; custom domains need configuration; ECS uses ACM on a load balancer you provision | Control Plane creates and renews TLS certificates for default endpoints and custom domains |
| Secrets | Your team writes secret manager resources; the platform encrypts run variables | A template calls the underlying IaC | The service references a cloud secret manager you provision | Stored in Control Plane and granted to workloads through identity-based policies |
| Provider-managed databases | Your team writes RDS, Cloud SQL, or equivalent resources | A template calls the underlying IaC | Not provisioned by the service | Not provisioned by the platform; stays in IaC |
| Open-source databases you run yourself | Your team writes compute, storage, and configuration | A template calls the underlying IaC | Not a fit for persistent databases | Control Plane’s Template Catalog deploys services such as PostgreSQL and Redis from templates |
| VPCs and networks | Your team writes VPC, subnet, and peering resources | A template calls the underlying IaC | Default networking; custom networking needs IaC | Not provisioned by the platform; stays in IaC, and Control Plane’s Cloud Wormhole reaches private resources in your VPCs through an agent you install |
| IAM roles and policies | Your team writes IAM resources | A template calls the underlying IaC | A service identity; additional IAM needs IaC | Control Plane’s Universal Cloud Identity (UCI) lets workloads call AWS, GCP, and Azure services with no long-lived cloud keys in your code, and Control Plane creates the least-privilege cloud role or service account for each identity; the one-time cloud account grant stays with you, and account-level IAM stays in IaC |
| DNS zones | Your team writes Route 53, Cloud DNS, or equivalent resources | A template calls the underlying IaC | Not provisioned by the service | Your zone stays with your DNS provider; delegate a subdomain to Control Plane with an NS record and Control Plane creates its records, or point a CNAME at the workload endpoint |
| Object storage buckets | Your team writes S3, Cloud Storage, or equivalent resources | A template calls the underlying IaC | Not provisioned by the service | The Template Catalog deploys S3-compatible object storage such as SeaweedFS; cloud buckets such as S3 stay in IaC, and workloads reach them through UCI |
| Queues and event services | Your team writes SQS, Pub/Sub, or equivalent resources | A template calls the underlying IaC | Not provisioned by the service | The Template Catalog deploys message brokers such as Kafka, NATS, and RabbitMQ; cloud services such as SQS or Pub/Sub stay in IaC |
| Per-environment preview copies | Your team duplicates workspaces or stacks | Templates can take an environment parameter | Revisions or separate services per environment | A separate GVC holds the preview copy’s workloads |
Hosted IaC platforms and portals are general purpose, so your team writes every resource definition. Serverless container services take the application layer and leave the rest to you. A workload platform such as Control Plane also covers TLS, secrets, per-workload cloud identity, DNS for delegated subdomains, and open-source databases, message brokers, and S3-compatible storage from its Template Catalog, while cloud resources outside it stay in IaC.
What should a small team start with?
The right starting stack depends on team size, compliance scope, and how many cloud resources live outside the application layer.
| Team | Application layer | Cloud resources | Guardrails | What to add later |
|---|---|---|---|---|
| 1 to 5 engineers | A managed runtime or a workload platform such as Control Plane | A small Terraform or Pulumi stack for networking, a provider database, and DNS, run on a hosted IaC platform’s free tier (HCP Terraform Free covers up to 500 managed resources) | Plan review on pull requests; a few policy-as-code rules; OIDC so CI holds no long-lived keys | Environment promotion gates, more policy rules |
| 5 to 20 engineers | The same runtime, with more services and environments | A paid hosted IaC tier with a workspace or stack per environment and shared modules | Policy as code, RBAC on IaC workspaces, OIDC for CI | A self-service catalog for common resources, cost alerts |
| 20 to 50 engineers with no platform team | The same runtime, with separate environments per team | A module registry and shared modules owned by a rotating infrastructure group | Mandatory plan approval for production, audit logging | A dedicated platform role, golden-path templates |
| Regulated team (SOC 2 or HIPAA evidence) | A runtime with an audit trail and encryption at rest | A hosted IaC platform with drift detection, encrypted state, and access logging | Policy as code for tagging, encryption, and network rules; OIDC | Continuous compliance reporting, evidence export |
Three practices cover the guardrails a platform team usually sets up first. Require plan review on every pull request, since hosted IaC platforms run a plan on each pull request, link the result there, and can require manual approval before an apply. Adopt policy as code early. HCP Terraform supports Sentinel, OPA, and its native HCL-based Terraform policy framework, Spacelift and env zero support OPA, and Pulumi Cloud supports Pulumi Policies (formerly CrossGuard). A handful of rules catches untagged, oversized, and unencrypted resources before apply. Use OIDC federation so CI authenticates to clouds with short-lived tokens and stores no cloud keys. Developer self-service with guardrails covers these patterns in more depth.
When do you actually need a platform team?
A team can run without a dedicated platform team while its tools absorb the operational work, and these signals show when that stops holding.
- Services and environments grow faster than anyone can review changes across all of them.
- You run several clouds or many accounts with separate networking and IAM boundaries.
- Compliance scope requires continuous evidence collection, beyond point-in-time audits.
- Custom networking such as transit gateways, private connectivity to on-premises systems, or a service mesh takes engineering time every sprint.
- Teams copy IaC modules with small variations because nobody owns shared patterns.
- Infrastructure incidents fall to whoever last touched the Terraform file.
When several of these signals appear together, it is time to staff a dedicated platform role. Production-grade infrastructure without a platform team covers how far managed tools can take you before that point.
How does Control Plane fit without a platform team?
Control Plane handles Day 2 operations for you, including autoscaling, built-in observability, and security.
Workloads run on Control Plane-managed locations in AWS, GCP, Azure, and Oracle Cloud regions with no Kubernetes cluster for you to build or operate. A GVC is Control Plane’s named set of locations, and a workload runs in every location of its GVC. Control Plane also runs VM workloads on locations joined through Control Plane’s Managed Kubernetes, and workloads on Kubernetes clusters you already run or your own machines, including on premises.
The CLI, console, Terraform and Pulumi providers, and the Control Plane MCP server all work through the same Control Plane API. Control Plane can export its configuration as Terraform, and the MCP server lets AI assistants deploy, diagnose, scale, and roll back workloads.
Security defaults include a deny-by-default internal firewall, mTLS between workloads, and a tamper-proof audit trail, and access is controlled through Control Plane policies. Control Plane is PCI DSS Level 1, SOC 2 Type II, HIPAA, and GDPR compliant.
Control Plane does not provision cloud resources outside it, such as VPCs, provider database services like Amazon RDS, cloud storage and queue services, or account-level IAM. Keep a small Terraform or Pulumi stack for those resources, run it on a hosted IaC platform such as HCP Terraform, Spacelift, env zero, or Pulumi Cloud, and use the Control Plane providers for workloads in the same repository.
The best internal developer platforms compares platform engineering tools for teams without a platform team, and standardizing CI runners and pipelines covers the build side.
FAQ
Short answers on infrastructure as code and provisioning without a platform team.
What is the best platform as a service for infrastructure as code and provisioning without a platform team?
Usually two products together, a managed runtime or workload platform for applications and a hosted IaC run platform for networks, databases, and IAM. The phrase spans hosted IaC platforms, developer portals, and managed runtimes, and no single product covers all three.
Is Terraform too much for a team without DevOps engineers?
Not on its own. The work comes from state backends, credentials, CI pipelines, and module design. A hosted IaC run platform such as HCP Terraform or Spacelift removes the state and runner work, and keeping Terraform to the few resources outside a managed runtime keeps the module count small.
What is the difference between a PaaS and an IaC platform?
A PaaS runs and manages your application runtime. An IaC platform provisions cloud resources from code you write, so you define and maintain each resource yourself.
Is Backstage worth it without a platform team?
Usually not at first. Backstage provides a portal and software catalog but does not provision infrastructure on its own, and someone has to build templates and run the instance. Small teams often start with the self-service features of a hosted IaC platform and add a portal once someone owns it.
Is Pulumi or Terraform better for a small team?
Either works, since both provision the same range of cloud resources. Pulumi uses general-purpose languages, which suits application engineers, while Terraform’s constrained HCL is easier to review for people who do not write application code daily.
How do developers self-serve infrastructure safely?
By choosing from pre-approved modules behind three guardrails, which are plan review on pull requests, policy as code, and OIDC federation so CI holds no long-lived cloud keys. Self-service catalogs in hosted IaC platforms let developers deploy approved modules from a form.
Do I still need infrastructure as code if I use a managed runtime?
Yes, for a smaller set of resources. VPCs, provider databases, account-level IAM, DNS zones, and cloud storage and queue services still belong in IaC.
How does Control Plane work with Terraform and Pulumi?
Through its Terraform and Pulumi providers, which define workloads, GVCs, identities, and policies as code next to your other cloud resources. Resources outside Control Plane stay in the standard cloud providers in the same repository.
Talk to the Control Plane team about running the application layer without a platform team, or sign up free.





