Almost nobody arrives at this question because Terraform stopped working. It works. The plan output is still the clearest review artefact in infrastructure, the provider ecosystem is still the largest, and the hiring pool is still the deepest.
People arrive because a licence changed and somebody in legal or security asked a question that the engineering team could not answer with a shrug. HashiCorp moved Terraform from the Mozilla Public License to the Business Source License, a fork appeared under foundation governance, and suddenly a decision that had been settled for years was open again.
That makes this a migration article, not a selection article. You already have an estate. You have state files, modules, CI pipelines, a review process, and people who know the tool. The question is not which is theoretically best. It is what breaks, what it costs, and whether the thing you gain is worth the week you spend.
The honest summary up front: one alternative is a near drop-in and the rest are re-architectures. Knowing which is which before you start is most of the value here.
Key takeaways
- The licence change matters most to vendors, platform teams shipping infrastructure inside a product, and organisations with a written policy on source-available licences. For a team running its own infrastructure, it is usually a policy question rather than a practical one.
- OpenTofu is a state-compatible, provider-compatible fork, so migration is realistically a binary swap plus a test cycle. Divergence between the two now runs in both directions and is the thing to test for.
- The general-purpose language argument is real for dynamically generated infrastructure and overstated for everything else, because the constraint of a configuration language is what makes plan review tractable.
- Moving state backends is cheap in mechanics and expensive in coordination. The command is quick. Draining in-flight work, re-pointing CI, and re-establishing locking are where the time goes.
What the licence change actually changed
The Business Source License is source-available, not open source. You can read the code, modify it, and run it. What you cannot do is offer it as a competing commercial product, and older versions convert to an open licence after a defined period.
That maps cleanly onto three groups.
If you run infrastructure for your own organisation, the restriction does not bite. You are not competing with the vendor by managing your own cloud estate. The practical impact is close to zero, and the decision becomes a policy and governance preference rather than a compliance requirement.
If you build a product on top of it, the calculation is entirely different. A platform that runs plans for customers, a tool that embeds the binary, a managed service that wraps the workflow, all of these sit near or across the line. This is the group that funded and adopted the fork first, and for them the question answered itself.
If your organisation has a written licence policy, the answer is whatever the policy says, and engineering opinion is not the deciding input. Plenty of enterprises maintain an approved-licence list where source-available licences require an exception process per artefact. In those places the fork wins on paperwork, not on merit.
Be clear about which group you are in before spending engineering time. A migration justified by “the licence changed” that does not actually affect you is a week spent on principle, which is a legitimate thing to spend a week on but should be named as such.
OpenTofu compatibility in practice
The fork was created from the codebase at the point of the licence change, which means state format, configuration syntax and the provider protocol all started identical. Providers are consumed unchanged, because the provider protocol is the stable boundary and providers themselves are separately licensed.
In practice, a migration for most estates looks like this: point your tooling at the new binary, run a plan against a non-production state, confirm it reports no changes, then repeat per state file. A plan that reports no changes is the strong signal, because it means the tool read your configuration and your state and agreed with reality.
The places it is not that simple are worth enumerating, because they are where the week goes.
Version drift in both directions. The two projects have added features independently. The fork shipped native client-side state encryption and earlier variable evaluation. Upstream has shipped its own additions. Configuration written against a newer feature on either side will not parse on the other. Modules you consume from public registries are the risk here, not your own code, because you did not choose when they adopted new syntax.
Commercial tooling around the workflow. Policy engines, cost estimators, security scanners, plan-comment bots and hosted runners grew up around the original. Most support both now, some support one well and the other nominally. Inventory every tool that reads a plan file or shells out to the binary, and check each one specifically rather than trusting a support matrix.
The hosted platform. If you use the vendor’s hosted service for state, runs and policy, you are not migrating a binary, you are migrating a platform. State moves, the run environment moves, the policy language may move, and the approval workflow has to be rebuilt somewhere. That is a genuine project, not an afternoon.
Provider version pinning. Migrations are a bad time to also move provider versions. Pin everything, migrate, verify no-change plans, then unpin as a separate change. Mixing the two makes every unexpected diff ambiguous.
Needs first-hand data: Run a no-change plan with both binaries against the same state file for each of your top ten state files, and record whether the plans are byte-identical. Any state where they differ is your actual migration work; every state where they match is a binary swap. That list, not a blog post, is your migration estimate.
The language argument, examined
The most common argument for Pulumi is that a general-purpose language beats a configuration language. It is usually presented as self-evident. It is not, and the version of it that survives scrutiny is narrower and more useful than the version people repeat.
Where the argument is genuinely right. When the set of resources is computed rather than written. Generating per-tenant infrastructure from a list of customers. Emitting a resource per entry in a schema. Building a topology whose shape depends on inputs. In a configuration language these become nested loops over maps of objects, dynamic blocks, and expressions that are write-only code. In a real language they are a loop, and the loop is readable a year later.
It is also right about testing. Unit testing the logic that decides what infrastructure to create, as opposed to testing the infrastructure itself, is straightforward when that logic is a function in a language with a test runner. In a configuration language it is not really possible, so people test the plan output instead, which is slower and coarser.
And it is right about types. A typo in a resource attribute name caught by a compiler at author time is caught meaningfully earlier than one caught by a provider at plan time.
Where the argument is wrong, or at least incomplete. The constraint of a configuration language is not only a limitation, it is a guarantee. A configuration file cannot read the current time, call an HTTP endpoint, or branch on an environment variable that nobody documented. That guarantee is what makes a plan reproducible and a diff reviewable. Once the infrastructure definition is a program, reviewing the change means reasoning about what the program will do, not reading what it declares.
This shows up concretely. Two people running the same program at different times can produce different plans if the program is non-deterministic anywhere, and nothing in the tool prevents that. The failure is rare and it is nasty, because the plan looks fine.
The second incomplete part is the team argument. A configuration language has a low ceiling and a very low floor. Anyone can read it. A TypeScript program that builds infrastructure through a class hierarchy is readable by TypeScript engineers and opaque to everyone else, including the operations person debugging it at 3am. Whether that matters depends entirely on who your on-call rotation actually contains.
The honest conclusion. Choose the general-purpose language when your infrastructure is generated rather than written, or when the people who own infrastructure are product engineers who work in that language every day. Choose the configuration language when infrastructure is mostly declared once and changed occasionally, and when review quality is what keeps you safe. Both answers are defensible. “Real languages are better” on its own is not.
The real cost of switching state backends
Almost every migration in this article involves state moving, and the cost is consistently misjudged in the same direction. The mechanics are cheap. The coordination is not.
What is cheap. Reconfiguring a backend and copying state is a supported operation with a built-in migration path. For a single state file with nobody else working, it is minutes.
What is not cheap.
Draining in-flight work. Every open pull request touching infrastructure has a plan generated against the old backend. Those plans are stale the moment state moves. You either merge or close everything in flight, or you accept re-planning them all, and on a busy repository that is a scheduling problem across teams.
Locking, verified rather than assumed. Different backends implement locking differently, and some object-storage configurations offer none unless you add a lock table explicitly. A migration is exactly when a missing lock does damage, because two people will be running commands. Verify the lock exists by deliberately taking one and confirming a second run is refused.
Credentials and network paths for every runner. CI runners, developer laptops, break-glass hosts and any automation that touches state all need new credentials and network reachability. Missing one means the first failure happens at the worst moment.
The secrets already in the old backend. State files contain generated passwords, keys and connection strings. Copying state to a new backend does not remove them from the old one. Snapshots, versioned objects and backups of the old location all still hold credentials and all need deliberate destruction or continued protection.
Rollback. Decide in advance what rollback means. Usually it means keeping the old backend read-only and untouched for a defined period so you can point back to it. That only works if nothing has applied against the new one, so the window is short and you should know how short before you start.
The pattern that works: migrate one low-stakes state file end to end, write down every step including the ones you forgot, then batch the rest against that runbook. Announce a freeze window for infrastructure changes across the batch. Verify a no-change plan from a CI runner, not just from a laptop, because the laptop has credentials the runner may not.
Needs first-hand data: Time a full state migration on one non-production state file from freeze to verified no-change plan in CI, counting every step including credential provisioning and lock verification. Multiply by your state file count and add coordination overhead. That figure is your migration budget, and it will be larger than the estimate you would otherwise have given.
Where these changes get executed and gated is a CI/CD platform question as much as a tooling one.
OpenTofu

OpenTofu is the licence-motivated fork, governed under a foundation and licensed under the Mozilla Public License. It reads the same configuration, consumes the same providers, and uses the same state format, which makes it the only alternative here that is a migration rather than a rewrite. It has since developed independently, most visibly with native client-side state encryption, which addresses the long-standing problem that state files are credential stores nobody treats as such.
Pros
- The migration for most estates is a binary swap plus a verification cycle, which no other option on this list can claim
- Permissive licence with foundation governance removes the policy question completely
- Native state encryption solves a real security problem without an external wrapper
- Provider ecosystem is shared, so resource coverage is unchanged on day one
Cons
- Divergence now runs both ways, and public modules written against newer upstream syntax can fail to parse
- Commercial tooling support ranges from first-class to nominal, and you have to check each tool individually
- Smaller community means fewer public answers when you hit an unusual failure
- Every language limitation you disliked in the original is still there, because compatibility was the design goal
Best for: Teams whose blocker is the licence, especially vendors and platform teams who embed infrastructure code in a product and need a permissive licence.
Pricing: Free and open source with no vendor and no bill. Third-party platforms sell hosted state and run execution around it, priced separately on their own meters.
Pulumi

Pulumi defines infrastructure as a program in TypeScript, Python, Go, C# or Java. The program runs, builds a resource graph through the SDK, and the engine reconciles that graph against state the same way a declarative tool does. Migration is not a conversion, it is a rewrite, though the project provides importers and a mechanism for consuming existing Terraform providers and modules, which softens the edge considerably.
Pros
- Loops, functions, types and package management remove the contortions a configuration language forces on generated infrastructure
- Infrastructure decision logic can be unit tested with ordinary test tooling
- Secrets are encrypted in state by default rather than by convention
- Can consume the existing provider ecosystem, so resource coverage is not the constraint
Cons
- Migration is a rewrite of your infrastructure codebase, and the importers get you to a starting point rather than to production-quality code
- A program can be non-deterministic and nothing stops it, which silently undermines plan reproducibility
- Reviewing imperative code is harder than reviewing declarations, and review is the main safety control in infrastructure
- Self-managing state is a deliberate configuration choice rather than the default path
Best for: Teams whose infrastructure is largely generated from data, or product engineering teams who own infrastructure and already live in one of the supported languages.
Pricing: The engine is open source and free to self-manage. The vendor’s hosted service is metered on managed resources, with a free individual tier and paid tiers adding policy, drift detection and access control.
AWS CDK
The AWS Cloud Development Kit writes AWS infrastructure in a general-purpose language and synthesises CloudFormation, which AWS then deploys and tracks. There is no state file to move, because state lives server-side in CloudFormation stacks. That is the single biggest practical difference, and it is genuinely attractive to teams tired of managing state. It is also the thing that makes migration hardest, because you are handing ownership of existing resources to a different control plane.
Pros
- No state file to store, lock, back up, or recover, since CloudFormation owns it
- High-level constructs collapse the dozens of resources a correct AWS setup needs into a few lines
- Automatic rollback on a failed deployment is a service guarantee rather than something you implement
- First-party, so new AWS capabilities land without waiting on third-party provider updates
Cons
- AWS only, so it is not a candidate if any second cloud exists or is plausible
- Migrating existing resources means importing them into CloudFormation stacks, which is slower and less forgiving than a state move
- CloudFormation’s failure modes become yours, including slow updates and stacks stuck in failed rollback
- What deploys is generated output, so debugging means reading a template you did not write
Best for: AWS-only teams, especially serverless and application-centric ones, who would rather trade portability for not owning state at all.
Pricing: The framework is free and open source. You pay for the AWS resources it creates; CloudFormation carries no charge for standard resource types.
Crossplane

Crossplane replaces the CLI-and-plan model with Kubernetes controllers that continuously reconcile cloud resources defined as custom resources. It is not a migration target so much as a different architecture: instead of engineers running applies, application teams create claims and controllers make them real. Its composition model lets a platform team publish an internal abstraction, which is the actual reason organisations adopt it.
Pros
- Continuous reconciliation means drift correction is structural rather than a scheduled job you remember to run
- Kubernetes RBAC and admission control govern infrastructure requests without building an approval system
- Composition gives platform teams a real self-service interface with a defined contract
- Infrastructure becomes manifests, which fits a GitOps workflow directly
Cons
- Automatic reconciliation will revert the emergency manual fix while you are still using it, which is a genuine incident risk
- Your cloud estate now depends on a healthy cluster, and losing cluster state is a severe recovery scenario
- Migrating an existing estate means importing resources under controller management, which is slow and high-stakes
- Provider maturity trails the established ecosystem, particularly for newer or less common services
Best for: Platform teams already invested in Kubernetes who want application teams to request infrastructure through an internal API instead of through pull requests.
Pricing: Open source under a permissive licence with no licence cost. Commercial distributions and hosted control planes are sold separately, metered on managed resources or control planes.
Terragrunt
Terragrunt is not an alternative to the engine, it is a wrapper around it, and it belongs here because a large share of people asking this question actually want its capabilities rather than a different tool. It addresses the things the core tool leaves to you: keeping backend configuration from being repeated in every state, wiring dependencies between states, and running a command across many states in dependency order. It works with both the original and the fork, which makes it orthogonal to the licence decision.
Pros
- Removes backend and provider boilerplate duplication across a large multi-state estate
- Dependency graphs between state files let one command apply many states in the correct order
- Encourages small state files by making many of them cheap to operate, which is the right blast-radius answer
- Works with either binary, so adopting it does not commit you on the licence question
Cons
- Another layer of indirection, and debugging means understanding both the wrapper and the tool underneath
- Its own configuration language and conventions are a second thing for new engineers to learn
- Wrapper-level abstraction can hide which state a command is about to touch, which is exactly the wrong thing to hide
- Solves organisation, not the language limitations or the licence, so it is not an answer to either complaint
Best for: Teams with many state files across many environments who are drowning in duplicated backend configuration and manual ordering of applies.
Pricing: Free and open source with no vendor and no bill. The maintaining company sells a commercial platform around it, priced separately.
SST
SST is a framework for defining full-stack applications and their infrastructure together, built on the Pulumi engine and the Terraform provider ecosystem. Its components are application-shaped rather than cloud-shaped, and its distinguishing feature is a development loop that routes real cloud events to code running locally. It is a Terraform alternative only for the application layer, and it is an honest fit for a specific kind of team rather than a general replacement.
Pros
- Application-level components handle the wiring, permissions and endpoints that raw resources make tedious and error-prone
- Live development against real cloud services removes emulator-versus-reality bugs entirely
- Per-developer and per-branch environments are designed in rather than bolted on
- Sits on an established engine and provider set, so raw resources remain reachable when the abstraction runs out
Cons
- Covers application infrastructure only, so networking, shared data stores and organisational structure need another tool
- The project has been through a significant architectural rewrite, which is a real adoption consideration
- The opinionated component model is uncomfortable to fight when your shape does not match it
- Small ecosystem, so unusual problems have few public answers
Best for: Product teams shipping serverless or container applications who want one TypeScript codebase covering both the app and the infrastructure it needs.
Pricing: The framework is open source and free. Optional hosted deployment and environment services are sold separately per seat or per environment.
How to choose
Start with the reason you are here, because it determines the answer more than any feature comparison.
If the licence is the reason, go to OpenTofu. It is the only option that is a migration rather than a rewrite, and anything else is answering a different question at much higher cost.
If duplicated backend configuration and manual apply ordering are the reason, you want Terragrunt, not a different engine. Adopt it and stay where you are on the licence question until you actually have to decide.
If the language is the reason, be specific about which limitation is hurting. If it is generated infrastructure or untestable logic, Pulumi is a real improvement worth the rewrite. If it is that the syntax is ugly, it is not worth a rewrite.
If state management is the reason and you are AWS-only, AWS CDK removes the problem by handing state to CloudFormation. Accept that you are trading portability and inheriting CloudFormation’s behaviour, both good and bad.
If self-service is the reason, Crossplane is the architectural answer, and you should evaluate it as a platform project rather than a tool swap.
| Alternative | Migration shape | Solves | Does not solve |
|---|---|---|---|
| OpenTofu | Binary swap plus verification | Licence policy, state encryption | Language limits, state organisation |
| Pulumi | Rewrite, with import assistance | Generated infrastructure, testing | Review simplicity, determinism |
| AWS CDK | Import into CloudFormation stacks | Owning state, AWS boilerplate | Anything outside AWS |
| Crossplane | Re-architecture around controllers | Self-service, continuous drift correction | Long-tail one-off resources |
| Terragrunt | Wrapper, additive | Duplication, multi-state ordering | Licence, language |
| SST | Rewrite of the application layer | App and infrastructure together | Shared networking and data platform |
Frequently asked questions
Is OpenTofu actually a drop-in replacement?
For most estates, close to it. State format and provider compatibility were the explicit design goals, so a no-change plan against your existing state is the realistic expectation. The exceptions are configuration using features that only exist on one side, modules from public registries that adopted newer upstream syntax, and any commercial tooling that shells out to the binary. Test with a no-change plan per state file before assuming it is free.
Will my existing modules work with alternatives?
Unchanged on OpenTofu, because it consumes the same module and provider formats. Partly on Pulumi, which can consume providers and has a path for reusing existing modules, though the surrounding code is rewritten. Not at all on AWS CDK, Crossplane or SST, which are different models with different definitions of what a module is.
Do I have to move state to change tools?
Not for OpenTofu, which reads the existing state file in place. Terragrunt does not move state either, it organises how you address it. Everything else involves either migrating state into a different backend or importing existing resources into a different control plane, and importing is substantially harder than migrating.
What is the safest order for a migration?
Pin provider versions. Migrate one low-stakes state file end to end and write the runbook as you go. Verify a no-change plan from a CI runner rather than a laptop, since the runner’s credentials and network path are what production actually uses. Freeze infrastructure changes across each batch. Keep the old backend read-only for a defined window. Then unpin providers as a separate change, never in the same one.
Does any of this change how I handle secrets?
It changes where they live but not the principle. State files contain resource attributes verbatim, including generated credentials, so every backend you copy state to becomes another credential store to protect and every old snapshot stays sensitive after the move. If you migrate, use it as the moment to adopt native state encryption and to tighten read access. The injection side of the problem is covered in secrets management for CI/CD pipelines.
Related reading
- Best infrastructure as code tools — the full category, state mechanics and the multi-cloud claim.
- Best CI/CD platforms — where plans and applies actually run, and how to gate them.
- Best GitOps tools — the reconciliation model that Crossplane borrows from.
- Best secrets management for CI/CD pipelines — credentials for an apply without long-lived keys.
- Best deployment and release orchestration tools — the layer that sits above provisioning.
- Best preview environment tools — per-branch infrastructure, which several of these make cheap.