Nov 19, 20268 min read

Cloud Foundry Alternatives in 2026

Where teams move Cloud Foundry apps today: Encore, Kubernetes with Korifi, Google Cloud Run, Amazon ECS on Fargate, Red Hat OpenShift and Heroku, with what replaces cf push, service bindings and CredHub in each.

Illustration for Cloud Foundry Alternatives in 2026

Cloud Foundry made cf push the standard for enterprise deploys: a buildpack stages the app and bound services appear in VCAP_SERVICES. It still works, but a foundation needs a platform team to run BOSH, Diego cells and service brokers.

The vendor side has shifted too, with IBM retiring its public service and Tanzu Application Service renamed and repackaged under Broadcom. Any move comes down to what replaces the buildpack deploy, what replaces bindings, and who runs the platform afterwards.

Cloud Foundry alternatives at a glance

EncoreKorifi on KubernetesGoogle Cloud RunAmazon ECS on FargateRed Hat OpenShiftHeroku
Replaces cf push withgit pushcf push (same CLI)gcloud run deploy --sourceImage build plus task definitionoc new-app or pipelinesgit push heroku
Replaces service bindings withResources declared in codeService bindings via KubernetesEnv vars and Secret ManagerEnv vars and Secrets ManagerOperators and SecretsAdd-ons
Runs inYour AWS or GCP accountYour clusterYour GCP projectYour AWS accountYour cluster or managedHeroku
Platform to operateNoneCluster and KorifiNoneVPC, ALB, IAMClusterNone
Local developmentencore run with local Postgres and Pub/SubLocal cluster or noneDockerDockerLocal clusterNone built in
Best forTeams leaving CF for their own cloudKeeping the CF APIBuildpack-style deploys on GCPAWS-native container appsKubernetes with enterprise supportSmall apps without cloud accounts

What does Cloud Foundry give you that an alternative has to replace?

A Cloud Foundry app is usually a 12-factor service with a manifest.yml, a route, and services from the marketplace bound to it. The binding is the part that ties code to the platform, because the app reads credentials from VCAP_SERVICES at startup:

// vcapServices mirrors the part of VCAP_SERVICES the app reads. type vcapServices map[string][]struct { Name string `json:"name"` Credentials map[string]string `json:"credentials"` } func postgresURI() (string, error) { var svcs vcapServices if err := json.Unmarshal([]byte(os.Getenv("VCAP_SERVICES")), &svcs); err != nil { return "", err } for _, s := range svcs["postgres"] { if s.Name == "orders-db" { return s.Credentials["uri"], nil } } return "", fmt.Errorf("orders-db is not bound to this app") }

Every alternative replaces that lookup with something else, along with buildpack staging, the router, CredHub for secrets and the marketplace brokers that created the Postgres, RabbitMQ and Redis instances in the first place.

Encore for Cloud Foundry-style deploys on your own AWS or GCP

Encore

Encore is a backend framework with built-in infrastructure, and it keeps the part of Cloud Foundry developers liked, a push that deploys the app, while dropping the foundation you had to run. The services an app used to bind from the marketplace become declarations in its code: a database, a Pub/Sub topic or a secret, which Encore provisions as RDS, SNS and SQS or Cloud SQL and Pub/Sub in your own account.

Application code passes through Encore and infrastructure guardrails to resources provisioned in your own AWS or GCP account.

Set up the app

Get started
brew install encoredev/tap/encore &&
encore app create
Copy

Run in your terminal to get started locally.

~
$ encore app create checkout --example=hello-world$ cd checkout && mkdir -p checkout/migrations

Replace three bindings with declarations

This checkout service used to bind a Postgres instance, a RabbitMQ exchange and a CredHub credential. In Encore each one is a declaration next to the endpoint that uses it:

// checkout/checkout.go package checkout import ( "context" "encore.dev/pubsub" "encore.dev/storage/sqldb" ) // Was a bound Postgres service instance in VCAP_SERVICES. var db = sqldb.NewDatabase("checkout", sqldb.DatabaseConfig{ Migrations: "./migrations", }) type OrderPlaced struct { OrderID int64 `json:"order_id"` CustomerID string `json:"customer_id"` } // Was a RabbitMQ exchange bound to the app. var OrderPlacedTopic = pubsub.NewTopic[*OrderPlaced]("order-placed", pubsub.TopicConfig{ DeliveryGuarantee: pubsub.AtLeastOnce, }) // Was a CredHub credential; set it with `encore secret set --type prod PaymentsAPIKey`. var secrets struct { PaymentsAPIKey string } type PlaceParams struct { CustomerID string `json:"customer_id"` TotalCents int64 `json:"total_cents"` } type PlaceResponse struct { OrderID int64 `json:"order_id"` } //encore:api public method=POST path=/checkout func Place(ctx context.Context, p *PlaceParams) (*PlaceResponse, error) { var id int64 err := db.QueryRow(ctx, `INSERT INTO orders (customer_id, total_cents) VALUES ($1, $2) RETURNING id`, p.CustomerID, p.TotalCents, ).Scan(&id) if err != nil { return nil, err } if _, err := OrderPlacedTopic.Publish(ctx, &OrderPlaced{OrderID: id, CustomerID: p.CustomerID}); err != nil { return nil, err } _ = secrets.PaymentsAPIKey // passed to the payment provider client return &PlaceResponse{OrderID: id}, nil }

encore run starts Postgres and the Pub/Sub broker locally and applies the migrations, a step Cloud Foundry never offered, as bindings only existed once the app was pushed. Where the insert and the publish must not drift apart, the transactional outbox package writes the event in the same transaction.

What happens to the rest of the foundation

Routes become API endpoints declared in code, staging becomes a container build from the code, and spaces map to environments such as staging and production, each with its own infrastructure. Encore provisions an IAM role for the service, or a service account on GCP, and can deploy into an existing Kubernetes cluster when the organization has standardized on one. The PaaS migration guide covers moving one service at a time, so a Cloud Foundry foundation and Encore can run side by side during the move.

Platform teams that ran Cloud Foundry to give developers self-service usually want the same for coding agents, and declarations fit that: an agent adds a database or topic in the same change as the code, tests it under encore run, and the deploy creates it within the account's guardrails.

Best fit: teams leaving a Cloud Foundry foundation who want push-to-deploy and managed services on their own AWS or GCP account, with local development that matches production.

Korifi on Kubernetes

Korifi

Korifi is a Cloud Foundry Foundation project that implements the Cloud Foundry API on top of Kubernetes. Developers keep cf push, cf bind-service and the manifest format, and apps run as Kubernetes workloads built with Cloud Native Buildpacks.

It is the gentlest move for developers and the heaviest for operators. Someone still runs the cluster, Korifi's controllers, a container registry and ingress, and service bindings still need something to create the Postgres or RabbitMQ behind them, whether a broker, an operator or a managed cloud service. Feature parity with a full Cloud Foundry foundation is not complete, so check the commands your pipelines use.

Best fit: organizations with a Kubernetes platform team that want to retire BOSH without retraining every developer on a new CLI.

Google Cloud Run

Google Cloud Run

Cloud Run is the closest managed match to the cf push experience on GCP. gcloud run deploy --source . builds the app with Google Cloud's buildpacks and deploys it as a service that scales to zero, with HTTPS, revisions and traffic splitting built in.

Bindings become configuration you wire per service: Cloud SQL through the Cloud SQL connector or Auth Proxy, Pub/Sub through the client library and a push or pull subscription, and secrets from Secret Manager mounted as environment variables, each with an IAM grant on the service account. Background workers that ran as Cloud Foundry apps without routes map to Cloud Run jobs or worker pools, depending on whether they finish or run continuously.

Best fit: stateless HTTP services moving to GCP that want buildpack deploys without operating a platform.

Amazon ECS on Fargate

Amazon ECS on Fargate

ECS on Fargate runs containers without managing hosts, and it is where many AWS-first teams land. There is no buildpack step by default, so the pipeline builds an image, pushes it to ECR and registers a task definition that names the image, CPU, memory, environment variables and secrets from Secrets Manager or Parameter Store.

The pieces Cloud Foundry hid become yours: a VPC with private subnets, an Application Load Balancer with listener rules in place of routes, a task role per service with the right policies, and RDS, Amazon MQ or ElastiCache instead of marketplace services. Infrastructure as code is close to mandatory, usually Terraform or CDK, which adds a second codebase to review for every new service.

Best fit: AWS-native teams with infrastructure engineers who want full control over networking and IAM for each service.

Red Hat OpenShift

Red Hat OpenShift

OpenShift is Kubernetes with an opinionated developer layer: Source-to-Image builds, routes, a web console and operators for databases and messaging. For enterprises that bought Cloud Foundry for vendor support, it offers a similar support relationship on a Kubernetes base, available self-managed or as managed services on the major clouds.

The trade is cluster operation and the Kubernetes learning curve. Developers move from manifests and cf commands to Deployments, Services and Routes, and the platform team takes on upgrades, operators and capacity planning.

Best fit: large organizations that want a supported Kubernetes distribution and already have the staff to run it.

Heroku

Heroku

Heroku shares Cloud Foundry's roots in buildpacks and git push deploys, and add-ons play the role of the service marketplace, injecting DATABASE_URL and similar variables. For small apps it is the least work to move to.

It runs on Heroku's infrastructure rather than your cloud account, which rules it out for organizations that ran Cloud Foundry precisely to keep workloads inside their own boundary, and private networking to existing AWS or GCP resources is limited compared with running in your own account.

Best fit: small teams and internal apps that do not need to run inside their own cloud account.

How to choose a Cloud Foundry alternative

Choose Encore if the goal is to keep push-to-deploy and managed services while running everything in your own AWS or GCP account, with no platform to operate and a local environment that matches production. Choose Korifi if retraining developers is the bigger risk than running Kubernetes. Choose Cloud Run for stateless services on GCP that fit buildpack deploys, ECS on Fargate when an infrastructure team wants every AWS knob, OpenShift for supported Kubernetes at enterprise scale, and Heroku for small apps that can live outside your cloud account.

Frequently asked questions

What is the best alternative to Cloud Foundry?

Encore is the strongest fit when you want the cf push experience on your own AWS or GCP account, with databases, Pub/Sub and secrets declared in code instead of bound through a marketplace. Google Cloud Run is the closest managed match for buildpack-style deploys on GCP, and Korifi keeps the cf CLI on Kubernetes if you need to stay on the Cloud Foundry API.

What replaces VCAP_SERVICES when leaving Cloud Foundry?

On Cloud Run and ECS you read connection details from environment variables or a secrets manager that you wire up per service, and Heroku injects add-on URLs such as DATABASE_URL. Platforms that declare resources in code connect them at runtime, so there is no binding JSON to parse.

Is Cloud Foundry still maintained?

Yes. The open source project continues under the Cloud Foundry Foundation, and commercial distributions such as Tanzu Platform for Cloud Foundry and the SAP BTP Cloud Foundry environment are still offered. Some providers have exited, such as IBM, which retired its public Cloud Foundry service in 2023.

Can I keep using cf push on Kubernetes?

Yes. [Korifi](https://github.com/cloudfoundry/korifi) is a Cloud Foundry Foundation project that implements the Cloud Foundry API on Kubernetes, so cf push, apps, routes and service bindings work against a cluster. You then operate the Kubernetes cluster, Korifi itself and the backing services.

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.

~/orders — claude
Claude Code
Claude Code v2.1.180Opus 5.5~/orders