Skip to content

How to Choose Infrastructure as Code Tools for Self-Service in a Small Platform Engineering Effort (2026): The Five Layers, a Selection Scorecard, and Your First Golden Path

A golden path drawn as a road: request, module, policy check, runner, then a provisioned resource
Blog
By Noah Grinstein
15 min read

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.

LayerWhat it doesCommon optionsPick this whenRelative upkeep (small team)
IaC engineDeclares and applies infrastructure resourcesTerraform, OpenTofu, Pulumi, AWS CDK, Crossplane, CloudFormation, BicepYou need to provision cloud resources outside a managed runtimeMedium
Runner and stateExecutes plans and applies, stores and locks stateAtlantis, HCP Terraform, Pulumi Cloud, Spacelift, env0, Scalr, self-hosted CITerraform, 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 catalogPackages reusable, versioned infrastructure patternsPrivate Terraform registry, Git tags with semantic versioning, Pulumi packages, Crossplane compositionsYou want developers to consume tested patterns instead of writing raw IaCMedium
Request interfaceLets developers trigger provisioning without editing IaC directlyPull-request template, Backstage scaffolder, Port self-service actions, CLI wrappersYou want to reduce the knowledge required to request infrastructureLow (PR template) to High (portal)
Policy and guardrailsEnforces security, cost, and compliance rules before applyOPA or Conftest, Sentinel, Pulumi Policies (formerly CrossGuard), Checkov, Kyverno (for Crossplane)You need automated governance without manual review of every changeMedium

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.

CriterionWhy it matters for a small teamHow to score itWeight
Language your team already knowsReduces onboarding time and review friction3 = team fluent, 2 = some experience, 1 = new languageSet by your team
Ecosystem of maintained modules or providersFewer modules to write from scratch means faster delivery3 = rich ecosystem with active maintenance, 2 = adequate, 1 = sparseSet by your team
Who runs state, locking, and runnersSelf-hosted state and runners add patching, upgrades, and lock debugging to the team’s work3 = fully managed, 2 = partially managed, 1 = fully self-hostedSet by your team
Policy as code supportAutomated guardrails replace manual review gates3 = native integration, 2 = plugin available, 1 = manual onlySet by your team
Drift detectionManual changes to cloud resources can cause outages and compliance gaps3 = built-in scheduled detection, 2 = available via add-on, 1 = not supportedSet by your team
Cost estimation in pull requestsPrevents surprise bills before apply3 = native in runner, 2 = third-party integration, 1 = not availableSet by your team
Portal or form integrationDetermines how easily you can add a developer-facing request interface later3 = native integration with portals, 2 = API available, 1 = no integration pathSet by your team
License and exit pathProtects against future license changes or vendor lock-in3 = OSI-approved open-source license, 2 = source-available with clear terms, 1 = proprietary with migration riskSet by your team
Multi-cloud supportMatters if you run workloads across more than one cloud provider3 = mature providers for all your clouds, 2 = partial, 1 = single cloud onlySet 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.

StepWhat to buildDone whenWhat to measure
1. Pick the most common requestIdentify 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 moduleCreate 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 checksWrite 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 requestsConnect 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 interfaceCreate 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 iterateTrack 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.

Run Unbreakable
Apps and Agents

Sign up free. No cloud accounts required.