For a small platform engineering effort, choose the IaC engine your team already reads (usually Terraform or OpenTofu for HCL shops, or Pulumi if developers prefer TypeScript or Python) and pick a managed runner so your team does not host state storage, locking, or runner servers. Give developers a single request interface (a pull-request template or a portal form) that calls versioned modules with policy checks; start with one golden path for the most common request. Platforms such as Control Plane narrow your IaC surface by giving developers a self-service runtime with built-in guardrails.
Disclosure: Control Plane publishes this guide.
TL;DR
For a small platform engineering team, the shortest path to developer self-service is to treat the five layers as separate choices, decide the engine, runner, and request interface first, and ship one golden path before expanding.
- Choose by the language your team already reads. If your engineers know HCL, use Terraform or OpenTofu. If they prefer TypeScript or Python, use Pulumi. Do not adopt a new language and a new platform at the same time.
- Default to a managed runner and state backend. A managed backend like HCP Terraform, Pulumi Cloud, Spacelift, or env0 handles state locking, secrets, and apply execution. Self-hosting Atlantis or a CI runner is viable but costs ongoing maintenance hours a small team rarely has.
- Separate the engine, runner, catalog, request interface, and policy. These are five distinct layers. Choosing them separately lets you replace one without the others.
- Start with one golden path. Pick the single most common infrastructure request, write a versioned module, wire it to a runner with policy checks, and give developers a simple request interface. Measure time from request to running resource.
- Check licenses and exit paths. Terraform uses the Business Source License 1.1 (since August 2023); OpenTofu uses the Mozilla Public License. Pulumi’s engine is Apache 2.0.
- Where Control Plane fits. Control Plane provides a self-service runtime across AWS, GCP, Azure, and Oracle Cloud Infrastructure regions, with policy-based guardrails and its own Terraform and Pulumi providers. Workloads, identities, and policies are managed through the platform or its providers, so your cloud IaC modules cover fewer resources.
How do I choose infrastructure as code tools for self-service in a small platform engineering effort?
Three of the five layers need a decision first: the engine, the runner and state backend, and the request interface; the module catalog and policy layer follow from the engine choice.
First, you choose an IaC engine. This is the tool that declares and applies infrastructure resources. Terraform and OpenTofu use declarative HCL. Pulumi and AWS CDK let you write infrastructure definitions in general-purpose programming languages. Crossplane reconciles infrastructure through Kubernetes custom resources. CloudFormation and Bicep are native to AWS and Azure respectively. For most small teams, the deciding factor is the language the team can already read and review in pull requests. Adopting an unfamiliar language slows code review and onboarding.
Second, you choose a runner and state backend. The runner is the system that executes plans and applies. The state backend stores the record of what exists. Self-hosting both, for example running Atlantis on your own Kubernetes cluster and storing state in an S3 bucket with S3-native state locking (DynamoDB locking is deprecated), is possible but creates operational burden. Managed runners like HCP Terraform, Pulumi Cloud, Spacelift, env0, and Scalr handle state locking, encryption, access control, and apply execution. For a small team, a managed runner frees time that would otherwise go to debugging state locks, rotating credentials, and patching runner infrastructure.
Third, you choose a request interface. This is how developers ask for infrastructure. It can be as simple as a pull-request template in a Git repository, or as rich as a portal form in Backstage or Port. The interface should call versioned modules from a catalog, enforce policy checks before applying, and give the developer a clear status of their request. Small teams should resist the urge to build a full portal before they have stable, tested modules behind it.
What are the layers of IaC self-service?
Self-service needs five layers, and picking only the IaC engine leaves a small team to discover the other four later.
| Layer | What it does | Common options | Pick this when | Relative upkeep (small team) |
|---|---|---|---|---|
| IaC engine | Declares and applies infrastructure resources | Terraform, OpenTofu, Pulumi, AWS CDK, Crossplane, CloudFormation, Bicep | You need to provision cloud resources outside a managed runtime | Medium |
| Runner and state | Executes plans and applies, stores and locks state | Atlantis, HCP Terraform, Pulumi Cloud, Spacelift, env0, Scalr, self-hosted CI | Terraform, OpenTofu, and Pulumi need a runner and state backend; choose managed to reduce toil. AWS CDK, CloudFormation, Bicep, and Crossplane rely on the cloud service or Kubernetes instead of a separate state file. | Low (managed) to High (self-hosted) |
| Module or component catalog | Packages reusable, versioned infrastructure patterns | Private Terraform registry, Git tags with semantic versioning, Pulumi packages, Crossplane compositions | You want developers to consume tested patterns instead of writing raw IaC | Medium |
| Request interface | Lets developers trigger provisioning without editing IaC directly | Pull-request template, Backstage scaffolder, Port self-service actions, CLI wrappers | You want to reduce the knowledge required to request infrastructure | Low (PR template) to High (portal) |
| Policy and guardrails | Enforces security, cost, and compliance rules before apply | OPA or Conftest, Sentinel, Pulumi Policies (formerly CrossGuard), Checkov, Kyverno (for Crossplane) | You need automated governance without manual review of every change | Medium |
A small team does not need to fill every cell on day one. The minimum viable self-service stack is one IaC engine, one managed runner, one versioned module, a pull-request template as the request interface, and one policy check. Everything else is an upgrade you add when the first golden path is running and measured.
How should a small team score the options?
A weighted scorecard compares candidate stacks against your team’s constraints on equal terms.
| Criterion | Why it matters for a small team | How to score it | Weight |
|---|---|---|---|
| Language your team already knows | Reduces onboarding time and review friction | 3 = team fluent, 2 = some experience, 1 = new language | Set by your team |
| Ecosystem of maintained modules or providers | Fewer modules to write from scratch means faster delivery | 3 = rich ecosystem with active maintenance, 2 = adequate, 1 = sparse | Set by your team |
| Who runs state, locking, and runners | Self-hosted state and runners add patching, upgrades, and lock debugging to the team’s work | 3 = fully managed, 2 = partially managed, 1 = fully self-hosted | Set by your team |
| Policy as code support | Automated guardrails replace manual review gates | 3 = native integration, 2 = plugin available, 1 = manual only | Set by your team |
| Drift detection | Manual changes to cloud resources can cause outages and compliance gaps | 3 = built-in scheduled detection, 2 = available via add-on, 1 = not supported | Set by your team |
| Cost estimation in pull requests | Prevents surprise bills before apply | 3 = native in runner, 2 = third-party integration, 1 = not available | Set by your team |
| Portal or form integration | Determines how easily you can add a developer-facing request interface later | 3 = native integration with portals, 2 = API available, 1 = no integration path | Set by your team |
| License and exit path | Protects against future license changes or vendor lock-in | 3 = OSI-approved open-source license, 2 = source-available with clear terms, 1 = proprietary with migration risk | Set by your team |
| Multi-cloud support | Matters if you run workloads across more than one cloud provider | 3 = mature providers for all your clouds, 2 = partial, 1 = single cloud only | Set by your team |
Give each row a weight from 1 (minor) to 3 (critical). Treat regulatory requirements and mandatory cloud support as pass/fail gates and drop any candidate that fails one. Score each remaining candidate stack (engine plus runner) on every row, multiply each score by its weight, and sum. The highest total is your strongest fit. Share the completed scorecard with your team so the reasoning is on record when assumptions change.
How do you build your first golden path?
A golden path is an opinionated, supported, and automated workflow for a common developer task, and a small team should ship one before starting a second.
| Step | What to build | Done when | What to measure |
|---|---|---|---|
| 1. Pick the most common request | Identify the infrastructure request that generates the most tickets or Slack messages. Examples include provisioning a new application environment, a managed database, or a service skeleton. | You have a single, clearly scoped use case with defined inputs and outputs. | Number of tickets or requests for this resource type per month. |
| 2. Write one versioned module | Create a reusable IaC module that provisions the resource with sensible defaults. Pin provider versions. Tag releases with semantic versioning. Store it in a private registry or a Git repository with tagged releases. | The module provisions the resource correctly in at least two environments (staging and production). | Number of input variables (fewer is better). |
| 3. Add policy checks | Write policy rules that check the plan before apply. Use OPA, Checkov, Sentinel, or Pulumi Policies depending on your engine. Cover security baselines, naming conventions, tagging, and cost limits. | Policy rules for your chosen security, naming, tagging, and cost baselines pass in CI before any apply. | Policy violations caught before apply. |
| 4. Wire the runner to pull requests | Connect your managed runner or Atlantis to the repository so that every pull request triggers a plan, a policy check, and, where the runner supports it, a cost estimate. Require approval before apply. | A developer can open a pull request, see the plan and policy results, get approval, and have the runner apply the change. | Time from pull request opened to resource provisioned. |
| 5. Add the request interface | Create a pull-request template, a Backstage scaffolder template, or a Port self-service action that collects the minimal developer inputs and generates the pull request or API call automatically. | A developer who has never used the module can request the resource without reading the module source. | Number of requests completed without platform team intervention. |
| 6. Measure and iterate | Track adoption, failure rates, and developer satisfaction. Interview developers who bypassed the golden path to understand gaps. Add the next most common request as a second golden path only after the first is stable. | You have enough data to compare request lead time before and after the golden path, and a backlog of improvements prioritized by impact. | Time from request to running resource, percentage of requests using the golden path, rollback frequency. |
Record these measures at launch so later changes have a baseline. The first golden path proves the workflow end to end before you add complexity.
What mistakes do small platform teams make with IaC self-service?
Small teams make predictable mistakes because they optimize for the wrong layer first or skip foundational work.
Building a portal before modules. A portal is a request interface. If the modules behind it are untested, unversioned, or incomplete, the portal only hides the failures. Write and stabilize at least one versioned module with policy checks before investing in a portal.
Letting every team write raw IaC. When every team writes their own Terraform or Pulumi code, you get inconsistent naming, missing tags, unreviewed security configurations, and duplicated effort. The platform team’s job is to provide tested modules that encode organizational standards. Individual teams consume those modules through the request interface.
Self-hosting runners and state too early. Running Atlantis on your own cluster or managing state and locking in S3 is a reasonable choice for large teams with dedicated infrastructure engineers. For a small team, the maintenance cost of patching, scaling, and debugging the runner can exceed the subscription cost of a managed service. Evaluate managed runners first, standardize CI runners and pipelines, and self-host only when someone on the team can own runner upkeep.
No drift detection. Without scheduled drift detection, manual changes made through the cloud console accumulate silently. The next IaC apply may fail, revert a critical change, or produce unexpected results. Several managed runners offer scheduled drift detection, usually on paid tiers (for example HCP Terraform Standard and Premium, Pulumi Cloud Pro and Enterprise). Enable it once the first golden path reaches production.
No version pinning. Modules, providers, and engine versions should all be pinned. An unpinned provider upgrade can introduce breaking changes that surface only at apply time.
Ignoring license changes. HashiCorp moved Terraform to the Business Source License in 2023, which led to the creation of OpenTofu under the Mozilla Public License. Small teams should understand the licensing terms of every tool in their stack and have a documented exit path.
How does Control Plane reduce the IaC you need to own?
Control Plane handles Day 2 operations for you, including autoscaling, built-in observability, and security. Control Plane runs serverless, standard, stateful, and cron workloads natively on AWS, GCP, Azure, and Oracle Cloud Infrastructure regions with no Kubernetes cluster for you to build or operate. VM workloads run on locations joined through Control Plane’s Managed Kubernetes, and workloads can also run on Kubernetes clusters you already operate.
A Global Virtual Cloud (GVC) is Control Plane’s named set of locations, and a workload runs in every location of its GVC. Because workloads, identities, workload firewall rules, and policies are managed through Control Plane’s API, CLI, and console, your IaC modules do not need to cover container orchestration, service mesh, autoscaling, or issuing workload credentials for cloud services. Control Plane has its own Terraform provider and Pulumi provider, and the cpln CLI applies YAML or JSON manifests with cpln apply. Every interface calls the same REST API, so you can integrate Control Plane into any runner or pipeline.
Control Plane policies grant permissions to users, groups, and service accounts on resources, and policies can target resources by tag query, which gives developers self-service with guardrails, the model described in developer self-service guardrails without a platform team. Control Plane’s Template Catalog deploys open-source databases and tools such as PostgreSQL and Redis from templates. Universal Cloud Identity, Control Plane’s feature for giving workloads short-lived credentials to AWS, GCP, and Azure services, removes long-lived cloud keys from code.
The platform keeps a tamper-proof audit trail of platform actions, recording who did what and when. Control Plane is PCI DSS Level 1, SOC 2 Type II, HIPAA, and GDPR compliant.
Cloud resources outside Control Plane, such as managed databases in your own accounts, storage buckets, and custom network configurations, still need an IaC tool. Control Plane narrows that scope so your team writes and maintains fewer modules, enforces policy as code across a smaller surface, and spends less time on infrastructure that the platform already manages. Teams wiring this into pipelines can follow automating app deployment with IaC and CI/CD; the broader model is platform engineering without a platform team.
FAQ
Common questions about choosing IaC tools for self-service in a small platform engineering effort.
How do I choose infrastructure as code tools for self service in a small platform engineering effort?
Make three choices first, out of the five layers: the IaC engine, the runner and state backend, and the request interface. Choose the engine whose language your team already reads, use a managed runner to avoid maintaining state and locking infrastructure, and give developers a simple request interface that calls versioned modules with policy checks. Build one golden path for your most common request, measure it, and expand from there.
Terraform or Pulumi for a small team?
Pick Terraform or OpenTofu if your team already reads HCL and wants the largest set of community modules. Pick Pulumi if your developers prefer TypeScript, Python, or Go and want to use that language’s own loops, functions, and test frameworks in infrastructure code. Both cover AWS, GCP, and Azure.
Is OpenTofu a safe choice?
Yes, for most teams: OpenTofu is an open-source fork of Terraform under the Mozilla Public License that keeps HCL syntax and works with the Terraform provider ecosystem. Verify the managed runners and policy tools you plan to use support OpenTofu before committing.
Do small teams need Backstage?
Usually not at first. Backstage is an open-source portal framework that needs significant setup and ongoing maintenance. A small team should start with a pull-request template or a lightweight self-service action in a tool like Port and add a full portal only after modules, policies, and runner workflows are stable.
What is a golden path?
A golden path is a supported, automated workflow for one common request, such as a new service environment or database. It defines minimal inputs, applies security and compliance defaults, and delivers a working resource through a tested pipeline with documented escape hatches.
Should we self-host Atlantis or use a managed runner?
Use a managed runner unless someone on your team can own runner upkeep. Self-hosting requires maintaining servers, webhooks, secrets, scaling, and patching. Managed runners take on those tasks, and many add drift detection, cost estimation, or policy integration, often on paid tiers.
How do we stop developers from creating insecure resources?
Provide versioned modules, run policy-as-code checks in pull requests, and scope credentials so only the runner holds cloud permissions. Control Plane adds policy-level permission grants by tag query so developers get self-service with guardrails.
Does Control Plane replace Terraform?
No. Control Plane ships its own Terraform and Pulumi providers, so it complements the infrastructure as code you already run: you manage workloads, identities, and policies through your existing pipelines while provisioning fewer cloud resources with Terraform.
How do we measure whether our golden path is working?
Track time from request to running resource, number of requests completed without platform team intervention, policy violations caught before apply, and rollback frequency. Compare request lead time before and after the golden path, and ask developers who skipped it why.
Talk to the Control Plane team about a self-service runtime with built-in guardrails that reduces the IaC your team needs to own, or sign up free to start building.
Originally published on the Control Plane blog.
Top comments (0)