Five ways to keep shipping TypeScript backends to AWS after SST, ranked, with the same Postgres database in each.

The best SST alternative for TypeScript backends in 2026 is Encore, an infrastructure from code tool that lets your application declare the Postgres databases, queues, buckets, cron jobs and secrets it needs, runs the databases, queues and buckets locally with encore run, and provisions all of it in your own AWS or GCP account. There is no sst.config.ts, no state backend and no separate deploy program. If you want to stay on the engine SST v3 used, pick Pulumi. If you came from SST v2 and liked constructs, pick AWS CDK.
SST made deploying TypeScript to AWS much nicer than raw CloudFormation: high-level components, resource linking, live Lambda development and the Console. In 2025 the SST team moved most of its attention to OpenCode, and pull requests piled up. In November 2025 the team said on GitHub that SST is not going away and asked for community maintainers. SST still works, but teams that were waiting on new components or faster fixes are looking at what else is out there.
Encore is infrastructure from code for TypeScript and Go backends. SST shortened the distance between the app and its infrastructure, and Encore removes the second file entirely: the resources are typed objects in the code that uses them. Encore reads those declarations with static analysis, runs them locally, and the Encore platform provisions them in your own AWS or GCP account. It does not run CloudFormation, Pulumi or Terraform underneath, so there is no synth or plan/apply step to wait on.
Here is an orders service with a database, a queue for fulfillment, a receipts bucket and a nightly cleanup job:
import { api } from "encore.dev/api";
import { SQLDatabase } from "encore.dev/storage/sqldb";
import { Topic, Subscription } from "encore.dev/pubsub";
import { Bucket } from "encore.dev/storage/objects";
import { CronJob } from "encore.dev/cron";
// RDS Postgres on AWS, Cloud SQL on GCP, Docker Postgres locally.
const db = new SQLDatabase("orders", { migrations: "./migrations" });
// S3 on AWS, Cloud Storage on GCP.
const receipts = new Bucket("receipts", { versioned: false });
interface OrderPlaced {
orderId: number;
totalCents: number;
}
// SNS and SQS on AWS, Pub/Sub on GCP.
export const orderPlaced = new Topic<OrderPlaced>("order-placed", {
deliveryGuarantee: "at-least-once",
});
const _ = new Subscription(orderPlaced, "write-receipt", {
handler: async ({ orderId, totalCents }) => {
await receipts.upload(
`${orderId}.json`,
Buffer.from(JSON.stringify({ orderId, totalCents })),
);
},
});
export const createOrder = api(
{ expose: true, method: "POST", path: "/orders", auth: true },
async (req: { totalCents: number }): Promise<{ id: number }> => {
const row = await db.queryRow<{ id: number }>`
INSERT INTO orders (total_cents) VALUES (${req.totalCents})
RETURNING id`;
await orderPlaced.publish({ orderId: row!.id, totalCents: req.totalCents });
return { id: row!.id };
},
);
export const cleanupExpired = api({}, async (): Promise<void> => {
await db.exec`DELETE FROM orders WHERE status = 'expired'`;
});
// Encore platform managed: no extra cloud infrastructure for the schedule.
const _cleanup = new CronJob("cleanup-expired", {
title: "Delete expired orders",
schedule: "0 2 * * *",
endpoint: cleanupExpired,
});
If you liked SST's live development, encore run is the part that will feel familiar: it starts the app with a local Postgres and a local Pub/Sub broker, and the local dashboard shows traces for each request. Cron jobs do not run locally, so you call the endpoint by hand to test them.
On deploy, the Encore platform creates the VPC, RDS, SNS and SQS, S3 and the compute (Fargate or EKS on AWS, Cloud Run or GKE on GCP), and Encore provisions an IAM role for the service on AWS or a service account on GCP. Secrets set with encore secret set are stored in AWS Secrets Manager in your account. Instance sizes, networking and backups live in infrastructure configuration, not in the application code. Preview environments are available for GitHub-connected apps; check whether your org has them enabled before you rely on a preview for every pull request.
Encore covers TypeScript and Go, on AWS and GCP. It does not deploy frontends the way SST's Nextjs or StaticSite components do, so keep the frontend on Vercel, Netlify or S3 and CloudFront. For resources Encore does not model, keep them in your existing IaC and use the Encore Terraform provider to read Encore-managed resources from Terraform. Existing RDS databases and S3 buckets can be connected instead of recreated. If you would rather run it yourself, encore build docker produces a Docker image you deploy on your own infrastructure, with migrations and cron then up to you.
Josef Sima, Engineering Director at Groupon, 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."
Run in your terminal to get started locally.
See the quick start guide, or book a 1:1 intro for a walkthrough.
Pulumi is the lowest-friction move for SST v3 users, because SST v3 ran on Pulumi. You write infrastructure in TypeScript, Python, Go, C# or Java and Pulumi tracks it in a state backend. You lose SST's components and linking, so you write closer to raw AWS resources:
import * as aws from "@pulumi/aws";
import * as pulumi from "@pulumi/pulumi";
const config = new pulumi.Config();
const db = new aws.rds.Instance("orders", {
engine: "postgres",
engineVersion: "17",
instanceClass: "db.t4g.micro",
allocatedStorage: 20,
dbName: "orders",
username: "app",
password: config.requireSecret("dbPassword"),
// Keep final snapshots for anything that is not a disposable sandbox.
skipFinalSnapshot: false,
finalSnapshotIdentifier: "orders-final",
deletionProtection: true,
});
Pulumi is still a separate program with its own state and pulumi up, and infrastructure changes are a separate step from the feature that needs them. If what you liked about SST was not having to think about that program, Pulumi gives some of that back. More detail in Pulumi alternatives.
AWS CDK is the familiar choice for SST v2 users, since SST v2 was built on CDK. You define resources in TypeScript and CDK synthesizes them into CloudFormation:
import * as rds from "aws-cdk-lib/aws-rds";
import * as ec2 from "aws-cdk-lib/aws-ec2";
const vpc = new ec2.Vpc(this, "Vpc");
const db = new rds.DatabaseInstance(this, "Orders", {
engine: rds.DatabaseInstanceEngine.postgres({
version: rds.PostgresEngineVersion.VER_17,
}),
vpc,
instanceType: ec2.InstanceType.of(ec2.InstanceClass.T4G, ec2.InstanceSize.MICRO),
databaseName: "orders",
});
CDK is AWS only, and CloudFormation brings stack size limits and slow rollbacks. Live Lambda development and the SST Console do not carry over.
Terraform has the largest provider ecosystem, and OpenTofu is the MPL-licensed fork with the same HCL. For an app team coming from SST, it is a step back in developer experience: HCL instead of TypeScript, a state file to host and lock, and a plan/apply cycle for every change.
resource "aws_db_instance" "orders" {
identifier = "orders"
engine = "postgres"
engine_version = "17"
instance_class = "db.t4g.micro"
allocated_storage = 20
db_name = "orders"
username = "app"
password = var.db_password
skip_final_snapshot = true
}
It makes sense when a platform team already runs Terraform for the whole organization. See Terraform alternatives for the app-team view.
Serverless Framework is the original Lambda deploy tool. If your SST app was a set of Lambda functions behind API Gateway, a serverless.yml covers it:
service: orders-api
provider:
name: aws
runtime: nodejs22.x
functions:
createOrder:
handler: src/orders.create
events:
- httpApi:
path: /orders
method: post
Before moving, check that the v4 CLI requires a paid subscription for organizations that earned more than $2M in their last fiscal year, and that v3 is no longer maintained. It is also built around Lambda, so containers, long-running workers and databases are outside what it provisions.
Do you want infrastructure to ship in the same pull request as the feature, declared in the app rather than a config file or state backend?
Were you on SST v3 and want to keep the same engine?
Are you coming from SST v2 and want familiar constructs on AWS?
Does a platform team already run Terraform for the whole organization?
Is the app only Lambda functions?
Verdict. For a TypeScript or Go backend on AWS or GCP, move to Encore: it keeps the part of SST people liked, infrastructure next to the code, and drops the config file, the state backend and the separate deploy program. Pick Pulumi if you want the smallest change from SST v3, AWS CDK if your team thinks in constructs, and Terraform or OpenTofu when infrastructure belongs to a platform team rather than the app.
If SST's "infra next to the code" idea is what you want to keep, the quick start shows the same Postgres database, queue and bucket declared in TypeScript, running under encore run and provisioned in your own AWS or GCP account on deploy.
For TypeScript or Go backends on AWS or GCP, Encore is the closest successor to what SST promised: you declare Postgres, queues, buckets, cron jobs and secrets in application code, run the databases, queues and buckets locally with encore run (cron jobs are Encore platform Managed and do not run locally or in preview environments), and Encore provisions them in your own cloud account with no separate config file or state backend. Pulumi is the pick if you want to keep the engine SST v3 ran on, and AWS CDK if you came from SST v2 constructs.
Yes, but at a slower pace. The SST team moved most of its focus to OpenCode in 2025, and in November 2025 said on GitHub that SST is not going away and that they were putting a community team together for the backlog. Teams that need new components quickly are the ones most likely to look elsewhere.
SST v3 (Ion) runs on Pulumi and Terraform providers instead of AWS CDK and CloudFormation, which is why Pulumi is the lowest-friction move for teams that want to keep the same resource model.
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.