Terraform has long helped platform teams standardize how infrastructure is provisioned and managed. As Terraform adoption grows across an organization, the next challenge is making that infrastructure easier for developers to consume.
Developers shouldn't need to understand every Terraform module, workspace, or organizational standard before they can get the infrastructure they need. At the same time, platform teams need to maintain control over what gets provisioned and how.
»We're investing in making self-service a native part of the Terraform experience.
That means giving developers a simpler way to discover and consume approved infrastructure, while giving platform teams the controls they need to define and govern those experiences. Increasingly, it also means making that same self-service foundation available to AI agents.
»Terraform Developer Portal: a native self-service experience for developers
Terraform Developer Portal (TDP), provides a native self-service experience for developers to discover, provision, and manage infrastructure through Terraform. Platform teams can expose existing Terraform modules as curated Templates, defining the inputs developers need to provide while maintaining control over how infrastructure is provisioned.
For example, a platform team might expose an approved AWS module as a Template such as Create an Application Service. Developers select the Template, provide the required inputs, and Terraform handles the underlying provisioning.
The resulting infrastructure is represented as an Application, which developers can extend with approved Add-ons, such as a PostgreSQL database. Terraform Actions provide approved operational workflows beyond initial provisioning.
Together, Templates, Applications, Add-ons, and Actions give developers a simpler way to consume and manage infrastructure while Terraform remains the underlying provisioning engine.
»Agentic self-service: bringing Terraform self-service to agents
The way developers interact with infrastructure is also changing. Today, a developer might open a UI or use a CLI to provision infrastructure. Increasingly, they may simply describe what they need to an AI agent.
For example:
Create a development application for the payments service and add a PostgreSQL database.
An agent could discover the approved infrastructure available to that developer, identify the appropriate Template, determine its required inputs, and initiate the same provisioning workflow available through TDP.
Or a developer might ask:
What infrastructure does the payments application have, and did the latest provisioning run succeed?
Instead of requiring the developer to navigate through multiple infrastructure resources, an agent could retrieve the relevant application and Terraform context and provide an answer.
The same approach can extend to other self-service workflows:
Add the approved database Add-on to my application.
Show me the available infrastructure I can provision.
Why did my infrastructure provisioning fail?
Run an approved Action against my application.
The important part of agentic self-service is that the agent doesn't bypass the platform team's existing controls. Agents operate through the same Terraform APIs and workflows, discovering and consuming infrastructure that platform teams have already made available through self-service.
Capabilities such as tfctl provide a way for humans, automation, and coding agents to interact with Terraform programmatically. MCP can further make Terraform context and self-service capabilities discoverable to agents.
This creates a model where UI, CLI, API, and agents are different interfaces into the same Terraform self-service foundation, rather than separate ways of managing infrastructure.
See how context becomes governed golden patterns that developers and agents consume through Terraform self-service.
»A broader self-service direction for Terraform
Terraform Developer Portal establishes the foundation for developer self-service. Platform teams define approved infrastructure and workflows, while developers get a simpler way to discover, provision, and manage them.
Agentic self-service extends that model by allowing developers to access the same capabilities through the tools and agents where they increasingly work.
The underlying model remains the same.
Platform teams define the infrastructure, workflows, permissions, and organizational standards. Terraform manages infrastructure provisioning and lifecycle. Developers choose what they need without having to understand all of the implementation details underneath.
Whether a developer starts from the TDP UI, CLI, API, or an AI agent, our direction is the same. We want to make the infrastructure organizations already manage with Terraform easier to discover and consume without sacrificing the control platform teams need.
»Get started with Terraform Developer Portal today
Terraform Developer Portal is available in your HCP Terraform account today. Ready to try it? Follow our getting started tutorial or explore the Terraform Developer Portal documentation.
