Seven tools ranked for application teams, with code, a comparison table, and when to pick which.

The best Terraform alternative for application teams in 2026 is Encore, infrastructure from code that provisions databases, Pub/Sub, buckets, and cron jobs from your application code, works with any framework, and deploys to your own AWS or GCP account or self-hosted with Docker. If you only want to drop the BSL license, use OpenTofu. If you want a separate IaC program in a real language, use Pulumi or AWS CDK.
This guide ranks seven tools, shows the same Postgres database in each, and ends with a plain verdict. Versions are current as of November 2026.
sst.config.ts, deployed with Pulumi.The ranking is for teams that build and ship application backends. A platform team that runs Kubernetes for the whole company will rank Crossplane higher, and a team that only wants a new license will stop at OpenTofu.
Encore removes the separate infrastructure codebase. You declare the resources a service needs as typed objects in TypeScript or Go, and Encore reads those declarations with static analysis to run everything locally and provision the matching managed services when you deploy. It is infrastructure from code, and it works with any framework: you can keep NestJS or Express in TypeScript, or Gin, Echo, Chi, and net/http handlers in Go through raw endpoints.
The same Postgres database that takes an aws_db_instance block plus networking and credentials in Terraform is one declaration:
import { api } from "encore.dev/api";
import { SQLDatabase } from "encore.dev/storage/sqldb";
import { Bucket } from "encore.dev/storage/objects";
import { Topic } from "encore.dev/pubsub";
const db = new SQLDatabase("orders", { migrations: "./migrations" });
const receipts = new Bucket("receipts", { versioned: false });
interface OrderPlaced {
orderId: number;
}
export const orderPlaced = new Topic<OrderPlaced>("order-placed", {
deliveryGuarantee: "at-least-once",
});
export const place = api(
{ expose: true, method: "POST", path: "/orders" },
async (req: { total: number }): Promise<{ id: number }> => {
const row = await db.queryRow<{ id: number }>`
INSERT INTO orders (total) VALUES (${req.total}) RETURNING id`;
await receipts.upload(`${row!.id}.json`, Buffer.from(JSON.stringify(req)));
await orderPlaced.publish({ orderId: row!.id });
return { id: row!.id };
},
);
Locally, encore run starts Postgres, the bucket, and Pub/Sub for you. In your own AWS account the same code maps to RDS, S3, and SNS with SQS; in GCP it maps to Cloud SQL, Cloud Storage, and Pub/Sub. Encore provisions an IAM role for the service. Instance sizes, networking, and backups live in environment configuration, outside the application code:

To self-host instead, encore build docker orders:latest produces a standard image you can run on any Docker or Kubernetes host, with the infrastructure connections described in a config file.
Run in your terminal to get started locally.
brew install encoredev/tap/encore && encore app create
Yes. Terraform keeps the shared and org-level infrastructure it already manages, Encore takes the application resources it supports, and the Encore Terraform provider lets your Terraform reference what Encore manages. Existing databases such as RDS and Cloud SQL can be connected rather than recreated. The migration guide walks through it.
Groupon is one team that made the switch. Josef Sima, Engineering Director at Groupon, put it this way on the customers page: "Encore is our foundation for all new development. What used to take days or weeks between developers and infra teams now takes minutes."
Yes, for nearly every project. OpenTofu forked from Terraform 1.5 after HashiCorp moved Terraform to the BSL in 2023, and it is maintained under the Linux Foundation with the MPL 2.0 license. It keeps HCL, the provider protocol, modules, and state, so existing files usually work after you swap terraform for tofu:
resource "aws_db_instance" "orders" {
identifier = "orders-db"
engine = "postgres"
instance_class = "db.t3.micro"
allocated_storage = 20
# plus credentials, subnet group, and security groups
}
It has added features Terraform does not have, such as client-side state encryption (since 1.7). It changes the license and the steward, not the workflow: you still maintain HCL and state, and an application change can still need a separate infrastructure change.
See also OpenTofu alternatives and OpenTofu vs Terraform.
Pulumi is better when HCL is the problem. Programs are written in TypeScript, JavaScript, Python, Go, C#, Java, or YAML, so you get loops, functions, packages, and type checking:
import * as aws from "@pulumi/aws";
import * as pulumi from "@pulumi/pulumi";
const config = new pulumi.Config();
const db = new aws.rds.Instance("orders-db", {
engine: "postgres",
instanceClass: "db.t3.micro",
allocatedStorage: 20,
username: "postgres",
password: config.requireSecret("dbPassword"),
skipFinalSnapshot: true,
});
The model is still a separate program with its own state and a pulumi preview and pulumi up cycle. State can live in Pulumi's hosted service or in a backend you run yourself, such as S3 or a local file. It is the best choice for a multi-cloud IaC codebase that a platform team owns.
Use AWS CDK when you are committed to AWS and want a real language instead of HCL or raw CloudFormation. CDK apps are written in TypeScript, JavaScript, Python, Java, C#, or Go, and cdk synth turns them into CloudFormation templates that AWS deploys as stacks:
const db = new rds.DatabaseInstance(this, "Orders", {
engine: rds.DatabaseInstanceEngine.postgres({
version: rds.PostgresEngineVersion.VER_16,
}),
instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.MICRO),
credentials: rds.Credentials.fromGeneratedSecret("postgres"),
vpc,
});
The construct library has deep AWS coverage and sensible defaults. The tradeoffs are AWS lock-in, CloudFormation limits, and a separate CDK app next to your service code. See AWS CDK vs Terraform.
SST is a good fit for TypeScript teams shipping full-stack apps on AWS or Cloudflare. Everything is defined in one sst.config.ts, deployed with Pulumi under the hood, and it can use any of the 150+ Pulumi and Terraform providers:
const vpc = new sst.aws.Vpc("MyVpc");
const db = new sst.aws.Postgres("MyDatabase", { vpc });
Resource linking exposes a resource to your code with Resource.MyDatabase, and sst dev deploys infrastructure changes through a watcher while your app runs locally. It does not require a Pulumi account, and the state stays in your own account. It still keeps a separate config file and a deploy step, and its built-in components focus on AWS and Cloudflare.
Nitric also infers infrastructure from application code. You declare APIs, buckets, queues, and topics with its SDKs for TypeScript, JavaScript, Python, Go, or Dart, and nitric up deploys them to AWS, GCP, or Azure through providers that generate Pulumi or Terraform. It is the closest tool to Encore in approach. The main differences are that Nitric deploys through a generated Pulumi or Terraform layer, while Encore provisions directly from its own model and includes local infrastructure, tracing, and preview environments.
Crossplane makes sense when Kubernetes is already your control plane. Cloud resources become Kubernetes objects that Crossplane continuously reconciles against AWS, GCP, or Azure, and Compositions let a platform team offer its own higher-level APIs. Crossplane v2 made managed resources namespaced:
apiVersion: rds.aws.m.upbound.io/v1beta1
kind: Instance
metadata:
name: orders-db
spec:
forProvider:
region: us-east-1
engine: postgres
instanceClass: db.t3.micro
allocatedStorage: 20
The prerequisite is large: a cluster, provider packages, credentials, and Compositions, before the first database exists. For teams without Kubernetes it is the heaviest option here. See Crossplane vs Terraform.
The verdict: Encore for application teams, OpenTofu for license-only moves, and Pulumi for platform teams that want to keep a separate IaC codebase.
For application teams, Encore is the strongest pick: it is infrastructure from code that works with any framework and provisions into your own AWS or GCP account, or runs self-hosted with Docker. OpenTofu is the best drop-in replacement if you only want to leave the BSL license, Pulumi is the best fit for a standalone IaC program in a general-purpose language, AWS CDK suits AWS-only teams, and Crossplane suits teams that already run Kubernetes as a control plane.
OpenTofu is a fork of Terraform 1.5, made after HashiCorp moved Terraform to the BSL in 2023. It is maintained under the Linux Foundation with the MPL 2.0 license, reads the same HCL, providers, and state, and has added features of its own such as client-side state encryption.
Pulumi is better if you want infrastructure in TypeScript, Python, Go, C#, Java, or YAML instead of HCL, with loops, functions, and type checking from a real language. It keeps the same plan and apply model and its own state, so the workflow is close to Terraform.
Yes. OpenTofu reads existing Terraform configuration and state, so teams switch the binary and keep their files. Pulumi can import existing resources and convert HCL, and most other tools here can run next to Terraform while you move one service at a time.
Deploy to your cloud on AWS and Google Cloud
without managing infrastructure
Encore lets developers and agents define application infrastructure directly in code, then automatically provisions it from local development to production in your AWS or GCP account.