Terraform vs OpenTofu vs Pulumi in 2026: which IaC tool to pick

· 8 min read · terraform · iac

Three years after the licence change, the fork has its own features, Terraform has kept shipping, and Pulumi now runs HCL. Here is how they actually differ and what we pick for startups.

For a new startup project in 2026 we default to OpenTofu: same HCL, same providers, an open-source licence under the Linux Foundation, and built-in state encryption that Terraform does not have. Terraform remains a sound choice if you want HCP Terraform and its newer platform features. Pulumi is the right pick when your team would rather write infrastructure in TypeScript, Python or Go than learn HCL.

Versions and licences below were checked on 1 November 2026: Terraform 1.17.1, OpenTofu 1.13.2, and the current Pulumi docs.

The three tools at a glance

Terraform and OpenTofu are near-twins with different licences and diverging feature sets; Pulumi is a different model that happens to reuse the same provider ecosystem.

TerraformOpenTofuPulumi
LicenceBusiness Source License 1.1 since August 2023MPL 2.0Apache 2.0
GovernanceHashiCorp (an IBM company)Linux Foundation; CNCF Sandbox projectPulumi Corporation
LanguageHCLHCLTypeScript, Python, Go, C#, Java, YAML, and HCL
ProvidersTerraform RegistryOpenTofu Registry, same providersNative Pulumi providers plus any Terraform/OpenTofu provider
State encryptionBackend-side only (e.g. S3 SSE)Client-side state and plan encryption built inSecrets encrypted in state; backend handles the rest
Managed platformHCP TerraformThird-party (Spacelift, env0, Scalr and others)Pulumi Cloud
Best forTeams invested in HCP TerraformMost teams writing HCL todayDeveloper-heavy teams that want real code

Licensing: what the BSL change actually means for you

If you only use Terraform to manage your own infrastructure, the BSL does not restrict you. It matters if you build a product that hosts or embeds Terraform, and as a signal of who controls the roadmap.

On 10 August 2023 HashiCorp moved Terraform from MPL 2.0 to the Business Source License 1.1 for future releases. The licensing FAQ states there are no restrictions on internal use; what is not allowed is offering a product that competes with HashiCorp's. Each release converts to MPL 2.0 four years after publication. Terraform providers stayed under MPL 2.0, which is why OpenTofu and Pulumi can use them.

OpenTofu forked from the last MPL release, joined the Linux Foundation in September 2023, and was accepted into the CNCF as a Sandbox project in April 2025, keeping MPL 2.0. Pulumi's engine and SDKs are Apache 2.0; Pulumi Cloud, the default state backend, is a commercial service.

In practice: for a startup, the licence is rarely a legal problem. It is a question of whether you want your core tooling owned by one vendor or by a foundation.

Feature differences in 2026

Terraform and OpenTofu are no longer drop-in identical. Each has features the other lacks, and the gap grows with every release.

OpenTofu-only features worth knowing

Terraform-only features worth knowing

Both now support ephemeral resources and native S3 state locking with use_lockfile. One difference there: Terraform marks DynamoDB locking as deprecated, while OpenTofu supports both with no plans to deprecate.

State encryption in OpenTofu, in practice

This is the feature that most often tips our recommendation. State files contain database passwords, private keys and connection strings in plain text; with OpenTofu you can encrypt them with a KMS key you control.

terraform {
  backend "s3" {
    bucket       = "acme-tfstate-eu"
    key          = "prod/network/terraform.tfstate"
    region       = "eu-central-1"
    encrypt      = true
    use_lockfile = true
  }

  encryption {
    key_provider "aws_kms" "state" {
      kms_key_id = "alias/tofu-state"
      region     = "eu-central-1"
      key_spec   = "AES_256"
    }

    method "aes_gcm" "state" {
      keys = key_provider.aws_kms.state
    }

    # Only while migrating existing plain-text state
    method "unencrypted" "migrate" {}

    state {
      method = method.aes_gcm.state
      fallback {
        method = method.unencrypted.migrate
      }
    }

    plan {
      method = method.aes_gcm.state
      fallback {
        method = method.unencrypted.migrate
      }
    }
  }
}

Run tofu apply once so the state is rewritten encrypted, then remove the unencrypted method and the fallbacks and set enforced = true in the state and plan blocks. Two warnings from the docs: don't rename key providers or methods once data is encrypted, since their names are stored as metadata, and remember that only OpenTofu can read the result. Encrypted state is a one-way door away from Terraform until you decrypt it again.

How to split that state into sensible pieces is a separate decision; our guide to Terraform state organisation covers the layout we use for startups, and it applies unchanged to OpenTofu.

Provider compatibility and state backends

All three tools can use the same providers, so provider coverage is no longer a reason to pick one over another.

OpenTofu resolves providers from its own registry, which serves the same MPL-licensed providers: hashicorp/aws works with no change to your code. Pulumi has native providers for the major clouds and can wrap any Terraform or OpenTofu provider with pulumi package add terraform-provider <name>.

State backends differ more:

Pulumi Cloud's pricing (checked 1 November 2026) has a free individual tier and team plans starting at $40 a month that bill per managed resource-hour through credits. For a small team a self-managed S3 backend in your EU region is a perfectly good start.

Team skills: HCL or a general-purpose language

The language question decides more projects than any feature table. HCL is limited by design, and that is often an advantage.

HCL is declarative and readable by anyone who has seen a Terraform file. Reviews are easy, junior engineers can follow it, and it is hard to write something too clever. Loops and conditionals exist but are awkward, which pushes you towards simple modules.

Pulumi gives you a real language: functions, classes, unit tests with the language's own tooling, and package managers for sharing components. That is valuable when infrastructure is generated from application logic, or when your team is all backend developers who will never enjoy HCL. The cost is that infrastructure code can grow abstractions as easily as application code does, and reviewers need to read programs, not configuration.

Your teamOur pick
Ops or DevOps engineers, existing HCLOpenTofu or Terraform
Full-stack TypeScript team, no infra hire yetPulumi (TypeScript)
Mixed team that will hire a DevOps engineerOpenTofu; HCL skills are the easiest to hire for
Platform team building self-service for developersEither; Pulumi's Automation API is a strong fit

A 2026 twist: Pulumi now has an HCL runtime that runs existing .tf files on the Pulumi engine. It is not a full Terraform emulation (backend and cloud blocks are ignored or rejected, and state is imported rather than read), but it lowers the cost of trying Pulumi without rewriting.

Migrating from Terraform to OpenTofu

For most codebases the migration is an afternoon: back up state, swap the binary, run a plan that should show no changes, apply once.

The official migration guide boils down to this:

# 1. Back up state (versioned bucket or an explicit copy)
aws s3 cp s3://acme-tfstate-eu/prod/network/terraform.tfstate ./backup/

# 2. Install OpenTofu and initialise in the same directory
tofu --version
tofu init

# 3. Must show "No changes" (or the same plan Terraform shows)
tofu plan

# 4. Apply once; this may update the state format
tofu apply

Things that catch teams out:

If your CI already deploys with short-lived credentials, nothing changes there; our GitHub Actions to AWS with OIDC setup works the same with tofu.

What we recommend for startups

Pick OpenTofu unless you have a specific reason not to, keep the code boring, and spend your energy on state layout and CI rather than on the tool choice.

  1. New project, team comfortable with HCL: OpenTofu, S3 backend in your EU region with use_lockfile, state encryption on from day one.
  2. Existing Terraform, no HCP Terraform dependency: migrate to OpenTofu when you next touch the pipeline. It is low risk and reversible until you adopt OpenTofu-only features.
  3. Existing Terraform on HCP Terraform and happy with it: stay. The licence does not affect internal use, and switching platforms costs more than it saves.
  4. Developer-only team that will not hire for infra soon: Pulumi in the language you already use, with a self-managed state backend or Pulumi Cloud.

Whichever you choose, the expensive mistakes are the same: one giant state file, manual changes in the console, and no plan review in CI. Our CI/CD anti-patterns post and AWS Organizations from day one cover the foundations around the tool.

If you are moving infrastructure into code as part of a bigger move, from Heroku, from click-ops or between clouds, our cloud migration service does it with OpenTofu or Terraform from the first resource, so you end up with infrastructure you can review, reproduce and hand over.

Frequently asked questions

Is OpenTofu a drop-in replacement for Terraform?

For most codebases written for Terraform 1.5 to 1.9, yes: same HCL, same providers, and the official migration is init, plan with no changes, then apply. Since then the tools have diverged. Terraform-only features such as HCP Terraform Stacks, list resources and actions do not exist in OpenTofu, and OpenTofu-only features such as state encryption do not exist in Terraform.

Can I still use Terraform for free after the BSL licence change?

Yes. HashiCorp's licensing FAQ says the Business Source License places no restrictions on internal use, so managing your own infrastructure with Terraform is fine. The restriction applies to offering a product that competes with HashiCorp by hosting or embedding Terraform. Providers remain under MPL 2.0.

Is Pulumi better than Terraform?

Neither is better in general. Pulumi suits teams that want to write infrastructure in TypeScript, Python or Go with real tests and abstractions. Terraform and OpenTofu suit teams that prefer declarative HCL that is easy to review and hire for. Pulumi can use Terraform providers, so provider coverage is rarely the deciding factor.

Does Terraform support state encryption like OpenTofu?

Not client-side. Terraform relies on the backend to encrypt state at rest, for example S3 server-side encryption with KMS. OpenTofu, since version 1.7, can encrypt state and plan files itself with AWS KMS, GCP KMS, OpenBao or a passphrase before they reach the backend. See our state organisation guide for backend layout.

Tell us what you need