Why reusable infrastructure modules are not the same as a reusable developer experience.
You can have well-designed Terraform modules, remote state, CI/CD pipelines, automated provisioning, and standardized security configurations.
And still force every development team to understand far more infrastructure than they should need to.
That's an important distinction.
Infrastructure as Code makes infrastructure reproducible. An internal developer platform should make supported engineering workflows easier to consume.
Terraform can be a critical component of that platform. But it isn't the whole platform.
The infrastructure is automated. Why is delivery still difficult?
Imagine an engineering organization running applications on AWS.
Its infrastructure team has invested in:
- Reusable Terraform modules for networking, IAM, compute, and databases.
- Remote state management.
- Automated infrastructure deployment pipelines.
- Standardized tagging and security configurations.
- Code review and approval workflows.
From an infrastructure perspective, this is meaningful progress.
Now imagine a developer joining the organization to deploy a new backend service.
They need to understand which modules to use, how those modules interact, which IAM permissions are required, how networking is configured, where application secrets belong, and how deployments work across environments.
Infrastructure provisioning has become repeatable.
But software delivery has not necessarily become self-service.
This is where the distinction between Infrastructure as Code and Platform Engineering becomes particularly relevant.
Terraform solves an important problem - but not every problem
Terraform provides a declarative approach to managing infrastructure.
Reusable modules allow infrastructure teams to encapsulate configurations, reduce duplication, and establish common patterns.
These are valuable capabilities, especially in organizations operating across multiple teams and environments.
But developers generally think about applications rather than infrastructure resources.
A developer might say:
"I need to deploy a containerized service to staging, with the standard observability configuration."
They are describing an application requirement.
They are not necessarily asking to select Terraform modules, configure provider-specific parameters, or manage relationships between infrastructure resources.
An internal developer platform should help translate those requirements into supported operational capabilities.
Terraform may still do much of the work underneath.
The architectural question is which complexity the platform should own, and which complexity developers actually need to understand.
The difference is in the interface
Consider two approaches that eventually rely on the same infrastructure provisioning technology.
Approach A: Exposing infrastructure configuration
In this approach, application teams interact directly with Terraform inputs.
A simplified configuration might look like this:
application_name = "payments-api" environment = "staging" runtime = "container" observability_profile = "standard" standard_tags = { managed-by = "example-platform" environment = "staging" } This approach is not inherently wrong.
For infrastructure-focused teams, direct Terraform access may provide exactly the flexibility and transparency they need.
But when the same model is applied indiscriminately across development teams, it can transfer infrastructure-specific responsibilities to people whose primary concern is delivering application functionality.
Approach B: Exposing application capabilities
Now consider a platform-owned contract:
apiVersion: platform.example.io/v1 kind: Application metadata: name: payments-api spec: runtime: container environment: staging observability: profile: standard The application team describes what it needs through a supported interface.
A platform-owned component validates the request and translates it into infrastructure configuration.
The platform can enforce supported environments, naming conventions, operational profiles, and standardized metadata without requiring every development team to configure those details independently.
Terraform remains underneath.
The difference is the interface and the ownership of the provisioning decisions.
The platform does not eliminate infrastructure complexity. It gives that complexity a deliberate owner.
A practical reference implementation
To make this distinction concrete, I built a small reference implementation:
terraform-is-not-a-platform — GitHub
The project demonstrates two ways of representing similar application requirements.
In the direct Terraform example, consumers provide infrastructure-oriented variables.
In the platform abstraction example, consumers declare application capabilities using YAML.
A small Python CLI validates the contract and generates native Terraform JSON configuration.
The architecture is deliberately minimal:
Approach A Application team | v Terraform variables | v Terraform configuration Approach B Application team | v Application contract (YAML) | v Platform-owned Python adapter | +-- Contract validation +-- Supported values +-- Standard metadata | v Generated Terraform JSON | v Terraform configuration The Python adapter provides a narrow set of platform-owned constraints:
- Supported environments:
dev,staging, andproduction. - Supported runtime:
container. - Observability profiles:
standardandenhanced. - Restricted application naming conventions.
- Rejection of unknown contract fields.
- Automatic injection of standardized tags.
For example, the application team does not need to define the managed-by tag. The adapter generates it as part of the infrastructure configuration.
The generated output is a valid main.tf.json file that Terraform can consume.
Try it locally
The project requires Python and, optionally, Terraform for configuration validation.
git clone \ https://github.com/rafaterrero/terraform-is-not-a-platform.git cd terraform-is-not-a-platform python3 -m venv .venv source .venv/bin/activate python -m pip install -r requirements.txt python -m pytest -q python -m platform_demo \ examples/platform-abstraction/service.yaml \ --output build/main.tf.json You can then validate the generated configuration:
cd build terraform init -backend=false terraform validate The implementation has passed its eight Python tests and Terraform configuration validation, including an automated GitHub Actions run.
An important limitation
This is intentionally a local-only demonstration.
It uses Terraform's built-in terraform_data resource rather than deploying real AWS services.
No AWS account, cloud credentials, or paid resources are required.
The example demonstrates contract validation, abstraction boundaries, and configuration generation.
It does not implement a production-ready developer platform, authorization, secret management, infrastructure deployment, policy-as-code, service lifecycle management, or operational observability.
Those responsibilities would require additional architecture and engineering.
The purpose of the repository is not to show that a YAML file and a Python script constitute a complete internal platform.
It is to demonstrate how the interface developers consume can be separated from the infrastructure implementation beneath it.
A lesson from working on an internal platform in banking
During my time contributing to the AWS architecture of Gluon Platform at Santander Digital Services, I worked with an internal application development and deployment platform where development teams could request infrastructure capabilities through an abstraction layer without interacting directly with Terraform.
That separation is an important architectural principle.
Developers could consume platform capabilities while the underlying infrastructure provisioning approach remained an implementation concern.
My work in this environment involved AWS architectural patterns, Terraform and CloudFormation, governance considerations, secure deployment models, and technical documentation.
It reinforced the importance of treating reusable infrastructure and developer-facing capabilities as related but distinct concerns.
Terraform can be part of the platform's implementation without becoming the interface developers are required to understand.
The GitHub example above is an independent educational implementation of that general principle. It does not reproduce Gluon Platform's internal architecture or code.
Golden paths should reduce friction, not create another bottleneck
A platform should make common engineering workflows easier and safer.
That often means providing golden paths: supported approaches to deploying and operating applications, with sensible defaults and established operational practices.
For example:
- Workload identities and appropriate IAM permissions.
- Approved networking patterns.
- Controlled secrets management.
- Standard deployment workflows.
- Logging, metrics, and troubleshooting conventions.
- Clear ownership and support boundaries.
These capabilities are especially important in regulated environments where security, traceability, and operational consistency matter.
But standardization alone is not enough.
A golden path that is too restrictive can become another source of friction.
Developers need supported defaults, but they also need documented ways to handle legitimate requirements outside the standard path.
A good platform should reduce unnecessary decisions without removing the information and control teams need to operate their services.
Abstraction should simplify consumption, not make systems impossible to understand or troubleshoot.
Platform Engineering is also a product discipline
Infrastructure automation is a technical capability.
An internal developer platform is also a product consumed by engineering teams.
That changes how its effectiveness should be evaluated.
Instead of focusing only on the number of Terraform modules, pipelines, or reusable components, we should ask:
- Can a development team onboard a new service without extensive platform-team intervention?
- How long does it take to reach a first successful deployment?
- How much infrastructure-specific knowledge is required?
- Are security and operational standards consistently applied?
- Can teams understand failures and recover without unnecessary escalation?
- Are platform capabilities actually adopted by their intended users?
These questions should lead to measurable indicators such as onboarding time, supported-path adoption, deployment lead time, support requests, and developer feedback.
None of these metrics alone proves that a platform is successful.
But together they provide a more useful picture than simply counting automation artifacts.
The platform should be evaluated by the engineering outcomes it enables, not merely by the infrastructure components it contains.
You may not need a developer portal
Another mistake is assuming that every internal developer platform needs a dedicated web portal.
A portal can improve discoverability, service ownership visibility, and access to supported workflows.
But a portal is not the platform itself.
Depending on organizational needs, a combination of versioned contracts, APIs, command-line tools, templates, CI/CD workflows, and documentation may offer an effective developer experience.
The right choice depends on the problems engineering teams actually face.
Building a sophisticated portal before identifying those problems risks creating another system that requires maintenance without delivering meaningful value.
Start with a repetitive, painful workflow.
Standardize it.
Make it secure, observable, and easy to consume.
Then expand based on actual usage and feedback.
Final thoughts
Terraform is not your internal platform.
Neither is Kubernetes, a collection of CI/CD pipelines, or a developer portal on its own.
All of them can contribute to a platform.
A platform becomes valuable when those capabilities are assembled into a coherent, supported developer experience that makes software delivery safer and more repeatable.
Terraform can make infrastructure reproducible.
Platform Engineering should make supported delivery workflows easier to consume and operate.
And the most useful question may not be how many Terraform modules an organization has built.
It may be this:
How much infrastructure complexity do developers still need to manage just to ship software safely?
Reference implementation: Terraform Is Not Your Internal Platform — GitHub
Further reading:

