In 2025, IBM acquired HashiCorp, the company behind Terraform. While Terraform has long been the standard in Infrastructure as Code (IaC), the acquisition marked a turning point. Changes to licensing, governance, and roadmap transparency have raised concerns in the community about the long-term direction of the tool—particularly its commitment to open source principles.

As a result, adoption has slowed in some circles, with teams increasingly evaluating alternatives.

The Rise of OpenTofu—and the Limits of the IaC Model

In response to these concerns, OpenTofu was launched as a community-driven fork of Terraform. Its goal is to preserve Terraform’s functionality while restoring an open, transparent development process. It’s seen solid adoption from teams that want continuity without vendor entanglement.

But OpenTofu, like Terraform, operates on the same fundamental model: infrastructure is managed in a domain-specific configuration language (HCL), separate from application code, and stored in state files that must be carefully coordinated across teams and environments.

This separation increasingly feels misaligned with how modern development works—particularly in an era where AI tooling is reshaping how software gets built.

The Growing Gap Between Infrastructure and Application Code

At the heart of the issue is the split between application logic and infrastructure configuration. With traditional IaC tools, infrastructure is defined in a separate language and codebase, often managed by a different team. This separation introduces several challenges:

• Cognitive overhead: Developers must context-switch between different domains (application code vs. infrastructure), and may lack full understanding of both.
• Coordination friction: Devs often depend on ops teams to provision or adjust infrastructure, slowing down iteration.
• State management complexity: Tools like Terraform rely on external state tracking, which can drift from reality if changes are made outside the tooling.
• Difficult automation with AI: Since infrastructure isn't declared in the same context or language as the application code, AI-based tools struggle to reason about the full system or generate infrastructure alongside features.

The Future is Moving Toward More Integrated, Declarative Infrastructure

Looking forward, there's a broader movement toward infrastructure models that are more tightly coupled with application code—defined using familiar programming languages, and automatically inferred or declared based on usage patterns.

In these systems, the boundaries between code and infrastructure blur. Infrastructure is no longer a separate concern to be managed manually, but something that emerges from the architecture of the application itself. This has several advantages:

• Better developer ergonomics: Developers work in one unified context, reducing context switching and making it easier to reason about the system.
• Improved automation: Tools—especially LLMs—can more easily understand and generate infrastructure when it's expressed alongside code.
• Simplified environments: When infrastructure is declaratively tied to application logic, spinning up preview environments or scaling systems becomes more straightforward.
• Reduced boilerplate: Many operational concerns can be abstracted away or inferred automatically.

Alternatives to Terraform in 2026

These days there are frameworks, like Encore, that are built ground up with declarative infrastructure in mind, which makes for a compelling alternative to using Terraform in 2026.

They don’t replace the value of infrastructure as code, but reframe it as an embedded part of software development rather than a standalone workflow. This means instead of defining your infrastructure in separate YAML or Terraform files, you can do it as part on the application code context — enabling LLM coding tools to build not only application logic but also defining the full cloud infrastructure layer.

Here's a video showing an example implementation using Encore's TypeScript framework and Cursor (an AI powered IDE):

Conclusion

Terraform helped standardize cloud provisioning and popularized the principles of infrastructure as code. But in 2026, the ecosystem is changing.

The IBM acquisition has accelerated a shift already underway: away from proprietary DSLs and disconnected tooling, and toward a more integrated, developer-centric model of infrastructure.

OpenTofu continues the Terraform tradition for those who want continuity and open governance—but the broader momentum is moving toward approaches where infrastructure lives closer to the application code.

As development becomes increasingly AI-assisted and automated, tools that unify application logic and infrastructure in a single, declarative context are emerging as the more sustainable, scalable choice.

Encore is the leading declarative infrastructure framework, with over 12k+ stars on GitHub.

Related Resources

• Encore vs Terraform — Detailed comparison of Infrastructure-from-Code vs IaC
• How to Deploy to AWS Without Terraform — Skip IaC configuration entirely
• Encore vs Pulumi — Compare with another popular IaC alternative