Nov 28, Paris: AI Health Hack #2 with Alan, Qovery and AWS. Applications close Nov 21

8 Cloudflare Workers and Pages alternatives for a real backend and database in 2026 (Kubernetes options ranked)

A fair buyer's guide for teams that outgrew the Cloudflare Workers and Pages edge-functions model: eight Kubernetes-based and container alternatives (Qovery on your own EKS, GKE or AKS, raw managed Kubernetes, Knative, Cloud Run, ECS/Fargate, Northflank, Render, Fly.io) judged on database, runtime limits, ops burden, pricing and exit path, plus when to stay on Cloudflare.

Alessandro Carrano
Head of Product
NOV 20, 2026 · 19 MIN
8 Cloudflare Workers and Pages alternatives for a real backend and database in 2026 (Kubernetes options ranked)

Key points:

  • You outgrow Workers when state and runtime matter more than the edge. A Worker isolate has 128 MB of memory and at most 5 minutes of CPU per request, a D1 database caps at 10 GB and runs one query at a time, and a single Durable Object stores up to 10 GB (Cloudflare Workers limits, D1 limits, Durable Objects limits).
  • Best overall for a team without a platform engineer: Qovery on your own EKS, GKE, AKS or Kapsule cluster. You get Kubernetes, a managed Postgres in your own VPC, preview environments per pull request and git-push deployments, and nobody on your team has to own cluster upgrades.
  • Best if you already have a platform team: raw managed Kubernetes (plus Knative if you want scale to zero). Maximum control, highest ongoing cost in people.
  • Best serverless step up: Google Cloud Run or AWS ECS on Fargate. Containers with no cluster to run, up to 32 GiB on Cloud Run and up to 120 GB (or 244 GB at 32 vCPU) on Fargate, but you are tied to one cloud's runtime.
  • Best for speed if you accept a vendor's account: Render or Fly.io. Northflank sits in between with a BYOC mode on AWS, GCP, Azure and others.
  • Stay on Cloudflare if your backend is still small and edge-shaped. Cloudflare Containers went GA in April 2026 and covers native dependencies up to 4 vCPU and 12 GiB per instance, without moving your database into your own VPC.

Qovery · Infrastructure control plane
Kubernetes, operated through one governed API
Learn more

Most teams I talk to did not choose Cloudflare Workers by mistake. They chose it because a Worker deploys in seconds, costs $5 a month to start, and puts the code close to every user. Then the product grew a relational schema, a background job that runs for 20 minutes, an image pipeline with a native library, and a customer who wants the database in a private subnet. That is when the "what now?" question lands on my desk.

I lead product at Qovery, so I have a horse in this race. I will still tell you where another option is the better pick, because a buyer's guide that ranks its own product first on every line is useless. If you have already decided to move and want the step-by-step port (D1 to Postgres, KV to Redis, Durable Objects export, the cutover), read our Cloudflare Workers to Kubernetes migration guide. This article is the step before: which platform should you move to.

When does a team outgrow Cloudflare Workers and Pages?

A team outgrows Cloudflare Workers and Pages when the backend needs a relational database with long-lived connections, more than 128 MB of memory per instance, jobs longer than 15 minutes, native binaries, or compute inside a private network. Those are hard platform limits, documented by Cloudflare, and no amount of code optimization removes them.

The limits that trigger most moves, straight from Cloudflare's docs:

  • Memory. "Each isolate can consume up to 128 MB of memory, including the JavaScript heap and WebAssembly allocations" (Cloudflare Workers limits).
  • CPU per request. 10 ms on the Free plan, 30 seconds by default on Workers Paid, configurable up to 5 minutes (Cloudflare Workers limits).
  • Background work. Cron Triggers, Queue consumers and Durable Object alarms each get 15 minutes of wall time (Cloudflare Workers limits).
  • Database size and concurrency. A D1 database caps at 10 GB on Workers Paid, and "each individual D1 database is inherently single-threaded, and processes queries one at a time". Cloudflare's own example: 1 ms average queries give about 1,000 queries per second, 100 ms queries give about 10 (D1 limits).
  • Stateful coordination. A SQLite-backed Durable Object stores up to 10 GB and has a soft limit of 1,000 requests per second per object (Durable Objects limits).
  • Outbound connections. Six simultaneous connections waiting for response headers per invocation (Cloudflare Workers limits).

Moving to Pages does not help. Pages Functions are billed like Workers, and Cloudflare's own migration guide says Workers offers "a distinctly broader set of features" than Pages (Cloudflare: migrate from Pages). If you hit these limits on Pages, you hit them on Workers too.

The signal I watch for is the workaround count. One Hyperdrive config is fine. Sharding data across D1 databases to dodge the 10 GB ceiling, splitting a job into 14-minute chunks, and keeping a sidecar VM for the native library means the platform is now shaping your architecture.

How did we pick and judge these alternatives?

We judged every option on six criteria that matter once a Workers app becomes a real backend: where your code and database run, the database story, runtime ceilings, who carries the ops work, the pricing model, and how hard it is to leave later. Kubernetes-based options score well on the last one by design, because the same container and manifests run on any conformant cluster.

  1. Whose account runs it. Your AWS, GCP, Azure or Scaleway account, or the vendor's. This decides data residency, VPC-private access and whether your cloud discounts apply.
  2. Database story. Can you run a managed Postgres or MySQL next to the app, inside a private network, with connection pooling?
  3. Runtime ceilings. Memory per instance, request timeout, long-running workers, native dependencies, GPUs.
  4. Ops burden. Who upgrades the cluster, patches nodes and wires ingress, TLS and secrets.
  5. Pricing model. Per request, per instance, per vCPU-hour, plus any platform fee.
  6. Exit path. If you leave the platform in two years, how much do you rewrite?

The options are the ones I see in real evaluations. Not every one is Kubernetes under the hood (Cloud Run, ECS and Fly.io are not), but all of them run standard OCI containers, so the app you build for one moves to another.

Which Cloudflare Workers alternatives fit a real backend and database? (comparison table)

The short answer: Qovery on your own cluster for teams without a platform engineer, raw managed Kubernetes for teams with one, Cloud Run or ECS/Fargate for a serverless step on one cloud, and Render, Fly.io or Northflank for the fastest move if you accept running in a vendor's account. Every row below stands on its own.

OptionBest forRuns in your cloud accountManaged database next to the appRuntime ceiling (memory / timeout)Who runs the platformPricing model (verified Nov 2026)Exit path
Qovery on your own EKS, GKE, AKS or KapsuleTeams without a platform engineer who need Kubernetes in their own accountYes (AWS, GCP, Azure, Scaleway, or any existing cluster)Yes, your cloud's managed Postgres or MySQL in your VPC, or a container databaseNode size you choose, no request timeout from the platformQovery operates the cluster and deployments; you own the accountFree plan (3 users, 1 cluster), paid plans from Starter; your cloud bill stays yoursStandard Kubernetes, Helm and Terraform; remove Qovery and the workloads stay
Raw managed Kubernetes (EKS, GKE, AKS)Teams with a platform team that want full controlYesYes (RDS, Cloud SQL, Azure Database)Node size you chooseYour team, including upgradesEKS: $0.10 per cluster-hour, $0.60 in extended support (AWS), plus nodesHighest portability, if you avoid provider-specific add-ons
Knative on your clusterScale-to-zero, request-driven services on Kubernetes you already runYesYes, same as the clusterNode size; per-revision timeouts you configureYour team runs Knative plus a networking layerOpen source; you pay for the clusterCNCF graduated, runs on any conformant cluster
Google Cloud RunStateless HTTP services and jobs on GCP with scale to zeroYes (GCP only)Cloud SQL32 GiB, 8 vCPU, 60 min request timeout (Google Cloud)GooglePer vCPU-second and GiB-secondContainer moves anywhere; Knative-style service YAML
AWS ECS on FargateAWS shops that want containers without a clusterYes (AWS only)RDS, AuroraUp to 16 vCPU and 120 GB, or 32 vCPU with 244 GB (AWS)AWSPer vCPU and GB, per second, 1-minute minimum (AWS)Container moves; task definitions and IAM do not
NorthflankPlatform UI with an option to run in your own cloudOptional (BYOC on AWS, GCP, Azure, Oracle, CoreWeave, Nebius)Yes, managed addonsPlan and node dependentNorthflank$0.01667 per vCPU-hour and $0.00833 per GB-hour on Northflank Cloud; BYOC $0.02083 per node vCPU-hour (Northflank)Containers move; platform config does not
RenderSmall teams that want the fastest PaaS moveNoRender Postgres, from $6/monthInstance size (up to 12 CPU, 96 GB listed)RenderPro $25/month plus compute; Standard web service $25/month for 2 GB (Render)Containers move; data export from Render Postgres
Fly.ioGlobally distributed apps and per-region machinesNoFly Managed Postgres, from $38/monthMachine size you pickFly.ioshared-cpu-1x 256 MB at $2.19/month, performance-1x 2 GB at $33/month (Fly.io)Containers move; Machines API config does not
Stay on Cloudflare (Workers, Containers, D1, Durable Objects)Edge-shaped apps, small data, bursty trafficNoD1 (10 GB per database) or external Postgres via HyperdriveWorkers 128 MB; Containers up to 4 vCPU and 12 GiB (Cloudflare)CloudflareWorkers Paid $5/month with 10M requests and 30M CPU-ms included (Cloudflare)Hono-style apps port quickly; Durable Objects take weeks

Is Qovery on your own EKS, GKE or AKS the best Cloudflare Workers alternative?

Qovery is the best pick when you want Kubernetes and a managed database inside your own AWS, GCP, Azure or Scaleway account, and you do not have (or do not want to hire) someone to operate the cluster. Pick something else if your team already runs Kubernetes well, or if you are a two-person team that will never need its own VPC.

Qovery is an Agentic DevOps platform that never hosts your apps. The Qovery control plane is separate from the data plane, which is the Kubernetes cluster in your own cloud account, and that separation is why it belongs in this list. When you leave Cloudflare for compliance or a private database, moving into another vendor's account solves half the problem.

What you get, concretely:

  • Your cluster, two ways. Qovery can create and manage a cluster in your account, or you connect a cluster you already run. The Qovery Operator installs once with Helm on EKS, GKE or Scaleway Kapsule (Kubernetes 1.31+), never stores your kubeconfig, opens an outbound connection, and builds images inside your cluster into your own registry (Qovery BYOK docs). AKS, k3s and on-premise clusters connect with qovery cluster install.
  • The database next to the app. Managed Postgres, MySQL or Redis through your cloud's own services (for example Amazon RDS through a Blueprint), or a container database for development environments.
  • The Workers developer experience you will miss. Git-push deployments, a preview environment per pull request, environment cloning, RBAC and audit logs.
  • Long-running work. Background workers, Kubernetes Jobs and CronJobs with no 15-minute cap, plus Helm charts and Terraform or OpenTofu services in the same environment.

Now the trade-offs. You pay your cloud bill for a cluster that does not scale to zero the way a Worker does, so a tiny, bursty API is cheaper on Cloudflare. Our existing migration guide does the math: Workers CPU works out to $0.072 per CPU-hour against $0.0408 for an m7g.large vCPU on AWS, so Kubernetes only wins on compute above roughly 57% average utilization (migration guide). Teams move for the database, memory and VPC, then win on cost once traffic is sustained.

Getting started costs nothing. The Free plan gives you 3 users plus unlimited AI agents, 1 cluster of your own, and 1,000 deployment minutes a month, with no credit card.

Should you run raw managed Kubernetes yourself instead?

Raw managed Kubernetes (EKS, GKE or AKS with Helm, Argo CD, cert-manager and an ingress controller) is the right call if you already have at least one engineer whose job is the platform. It gives you the most control and the cleanest exit path, and it costs the most in people.

The control plane fee is the easy part: $0.10 per cluster per hour on EKS during the 14 months of standard support, then $0.60 per hour in extended support (AWS EKS pricing). A cluster nobody upgrades costs six times more to keep running, and Kubernetes ships a new minor version roughly every four months (Kubernetes releases).

What you build yourself on day one: VPC and subnets, node groups or Karpenter, ingress and TLS, secrets, autoscaling, a CI/CD pipeline that builds and rolls out images, per-environment config, preview environments if you want them, and the database wiring. None of it is hard individually. Together it is a part-time job that never ends.

Pick raw Kubernetes if you have the team, need unusual networking (service mesh, multi-cluster), or your compliance team wants every controller under your own change management. Do not pick it if the person who would own it is also your lead backend engineer. That is exactly the situation where a platform like Qovery pays for itself.

Is Knative a good fit for teams leaving Cloudflare Workers?

Knative is a good fit when you already run Kubernetes and want the Workers-style request-driven model on it, including scale to zero. It graduated from the CNCF on 8 October 2025, alongside Knative 1.20 (CNCF), so maturity is no longer the question. Operations are.

Knative Serving needs a networking layer on top of the core install: Kourier by default, or Istio, Contour or the Gateway API integration (Knative install docs). Scale to zero is a first-class feature, which makes Knative the closest thing to the Workers billing feel on your own cluster.

Knative is a building block. It gives you revisions, traffic splitting and autoscaling for HTTP services. It does not give you the database, the CI pipeline, preview environments or cluster upgrades. Use it on top of raw Kubernetes when cold starts are acceptable and idle cost matters. Skip it if your services hold WebSocket connections or warm connection pools, because scale to zero works against both.

Run your backend and database in your own cloud account.
Qovery deploys your API, workers and managed databases on Kubernetes in your own AWS, GCP, Azure or Scaleway account, or your existing cluster. Free plan: 3 users, 1 cluster of your own, no credit card.

When is Google Cloud Run the better choice?

Google Cloud Run is the better choice when you are on GCP, your backend is stateless HTTP or batch jobs, and you want containers without any cluster at all. It is the most natural first step off Workers for a GCP team, because it keeps scale to zero and per-use billing.

The ceilings are much higher than a Worker: up to 32 GiB of memory, 8 vCPU, a 60-minute request timeout, and up to 1,000 concurrent requests per instance (80 by default) (Cloud Run quotas). Cloud SQL connects privately, so the database lands in your own GCP project.

Who should not pick it: multi-cloud teams, anyone who needs long-lived background workers that are not tied to requests, and teams that will hit the ceiling anyway. We ranked seven serverless container platforms by exactly when they force a Kubernetes move in Cloud Run vs App Runner vs Container Apps. Cloud Run sits late on that curve, which is a compliment.

When does AWS ECS on Fargate make more sense?

AWS ECS on Fargate makes sense for an AWS-only team that wants containers with RDS in the same VPC and no Kubernetes to learn. It handles big tasks (up to 16 vCPU with 120 GB, or 32 vCPU with 244 GB on Linux platform 1.4.0) and bills per second with a one-minute minimum (ECS Fargate task sizes, Fargate pricing).

One change matters if you are reading older comparisons. AWS App Runner stopped accepting new customers on April 30, 2026, and AWS now recommends Amazon ECS Express Mode for that use case (AWS App Runner). Treat App Runner as off the list.

The trade-off is lock-in at the configuration layer. Your container image moves anywhere, but ECS task definitions, service discovery and IAM task roles are AWS-specific, and Fargate does not accept the gpu task parameter. If a second cloud or GPU inference is on your two-year roadmap, start on Kubernetes instead and save yourself the second migration. We cover that move in our ECS to EKS migration page.

Is Northflank a good Workers alternative?

Northflank is a good alternative if you want a polished platform UI and the option to run either on its cloud or in your own. Its BYOC mode supports AWS, Google Cloud, Azure, Oracle, CoreWeave and Nebius, and its free Sandbox can connect one BYOC cluster of up to 12 vCPU and 48 GB (Northflank pricing).

Pricing is usage-based: $0.01667 per vCPU-hour and $0.00833 per GB-hour on Northflank Cloud, and $0.02083 per node vCPU-hour in BYOC mode, with memory not billed separately (Northflank pricing). No per-seat fees.

I would think twice about one thing. BYOC pricing scales with every node vCPU in your cluster, so the platform fee grows with your compute. Compare that against a plan-based model before you commit. If Northflank is already on your list, our Northflank alternatives post goes deeper.

When are Render or Fly.io the right move?

Render and Fly.io are the right move when speed matters more than whose account the database lives in. Both take a Dockerfile and give you a running service with a managed Postgres in under an hour, and neither asks you to learn Kubernetes.

Render fits small teams that want a classic PaaS. The Pro workspace is $25 a month plus compute, a Standard web service with 2 GB of RAM is $25 a month, and Render Postgres starts at $6 a month for 256 MB or $19 for 1 GB (Render pricing). Preview environments are built in on paid plans. Advanced governance sits on the Scale workspace at $499 a month plus compute.

Fly.io fits apps that want machines close to users in many regions, the closest thing to the Workers geography. A shared-cpu-1x machine with 256 MB costs $2.19 a month, a performance-1x with 2 GB costs $33, Managed Postgres starts at $38 a month, and egress in North America and Europe is $0.02 per GB (Fly.io pricing).

Who should not pick them: anyone whose reason for leaving Cloudflare is data residency in their own account, VPC-private databases or using cloud credits and committed-spend discounts. You would be moving from one vendor's infrastructure to another's. We compared this exact fork in Railway vs Render vs your own cloud account.

When should you stay on Cloudflare instead?

Stay on Cloudflare if your app is still edge-shaped: routing, auth checks, redirects, static and SSR front ends, bursty low-volume APIs, and a data set that fits comfortably in D1 or Durable Objects. Cloudflare closed some of the gap in 2026, and leaving too early is an expensive mistake.

The two Cloudflare features that change the calculation:

  • Cloudflare Containers is generally available since 13 April 2026, with active-CPU pricing and SSH access to live containers (Cloudflare changelog). The largest instance type, standard-4, has 4 vCPU, 12 GiB of memory and 20 GB of disk (Containers limits). Pricing beyond the Workers Paid allowance is $0.000020 per vCPU-second and $0.0000025 per GiB-second, with egress at $0.025 per GB in North America and Europe after 1 TB (Containers pricing). If your only problem is a native library or a non-JavaScript runtime, try this first.
  • Hyperdrive pools connections to an external Postgres or MySQL (Cloudflare Hyperdrive), so you can keep Workers at the edge and move only the database to a managed service.

What Cloudflare still does not give you: compute inside your own VPC next to a private database, instances above 12 GiB, GPUs for your own models, or a single cloud bill that counts toward your AWS, GCP or Azure commitment. The pattern I recommend most often is a split: keep DNS, CDN, WAF and the edge Workers on Cloudflare, and move the stateful core to Kubernetes in your own account behind the same orange-clouded hostname.

How do you choose between these options in practice?

Choose by your strongest constraint. The first rule below that matches your situation is usually the right answer.

  1. Data must live in your own cloud account or private network (enterprise customer, SOC 2 scope, residency): Qovery on your own cluster, raw Kubernetes, Cloud Run or ECS. Render and Fly.io are out.
  2. You have a platform team of two or more: raw managed Kubernetes, with Knative if scale to zero matters.
  3. You have no platform engineer and need Kubernetes features (workers, CronJobs, Helm charts, GPUs, multi-cloud): Qovery.
  4. You are all-in on one hyperscaler and your services are stateless: Cloud Run on GCP, ECS on Fargate on AWS.
  5. You want the fastest move and accept a vendor's account: Render for classic web apps, Fly.io for multi-region, Northflank if you want BYOC as a future option.
  6. Your only blocker is a native dependency or runtime: Cloudflare Containers before anything else.

A word on exit paths, since you are leaving one platform already. Every option here runs OCI containers, so your application code moves. What does not move is everything around it: task definitions, Machines config, platform YAML, IAM roles. Kubernetes manifests and Helm charts are the most portable layer available today, and Scaleway, OVHcloud, STACKIT and IONOS all ship CNCF-certified Kubernetes alongside the three hyperscalers (CNCF conformance, v1.35).

Can an AI agent do the migration off Cloudflare for me?

Yes, with a human approving the plan. On Qovery, an agent reads your repository and deploys it into the AWS account (or GCP project, Azure subscription, Scaleway project) you already own, after you approve the plan. The Qovery migration hub covers the common paths.

Be clear about what that means for a Workers app. There is no dedicated Cloudflare migration tool, and nothing reads your wrangler.toml or converts D1 bindings automatically. The coding agent uses the Qovery skills (qovery-onboard and qovery-deploy) to read your code, propose a Dockerfile, the services, a managed database and environment variables, and waits for your approval before creating anything. Porting the fetch handler and exporting D1 or Durable Object data is still your job, and the migration guide walks through it.

How do I deploy the new backend with Qovery from Claude Code or Cursor?

Install the Qovery Agent Skills once, then ask your coding agent in plain language. The agent proposes each action and you approve it; the MCP Server is read-only unless you explicitly enable write access.

Install the skills for every compatible agent (Claude Code, Cursor, Codex, OpenCode, Gemini CLI), or scope them to one project:

BASH
curl -fsSL https://skill.qovery.com/install.sh | bash
curl -fsSL https://skill.qovery.com/install.sh | bash -s -- --project

Add the Qovery MCP Server to Claude Code. It signs in with OAuth and is read-only by default:

BASH
claude mcp add --transport http qovery https://mcp.qovery.com/mcp --callback-port 4242

Only if you want the agent to change things through the MCP Server, add the write-enabled endpoint. This also requires enabling write access in the Qovery Console:

BASH
claude mcp add --transport http qovery "https://mcp.qovery.com/mcp?read_write=true" --callback-port 4242

Then ask: "deploy this API, its background worker and a managed PostgreSQL to my AWS account with Qovery, and create a preview environment per pull request." Swap AWS for GCP, Azure, Scaleway or your existing cluster. The skills that do the work are qovery-onboard, qovery-deploy and qovery-preview. Reference pages: the AI agent quickstart and the Claude Code integration.

Frequently asked questions
What are the Kubernetes-based alternatives to Cloudflare Workers and Pages for a real backend and database?

The main Kubernetes-based alternatives are Qovery on your own EKS, GKE, AKS or Kapsule cluster, raw managed Kubernetes with Helm and Argo CD, and Knative on a cluster you run. Container platforms without Kubernetes in the way include Google Cloud Run, AWS ECS on Fargate, Northflank, Render and Fly.io. Pick Qovery or raw Kubernetes when the database must sit in your own VPC, Cloud Run or ECS for a serverless step on one cloud, and Render or Fly.io for speed in a vendor's account.

Is Cloudflare Containers enough to avoid leaving Cloudflare?

Cloudflare Containers, generally available since April 2026, solves the native-dependency and non-JavaScript runtime problems for instances up to 4 vCPU and 12 GiB of memory. It does not put compute inside your own cloud VPC next to a private database, and it does not change D1's 10 GB per-database limit. If those are your blockers, you still need another platform for the stateful core.

What replaces D1 and Durable Objects when I move off Cloudflare?

D1 maps to a managed PostgreSQL or MySQL (Amazon RDS, Google Cloud SQL, Azure Database, Scaleway Managed Database) and Durable Objects map to Postgres rows with locks, Redis or Valkey, or a stateful service with sticky routing. Durable Object data has to be exported through the object's own code, which is why those migrations take weeks. Our Workers to Kubernetes migration guide covers the mapping step by step.

Is Kubernetes more expensive than Cloudflare Workers?

For a small, bursty API, yes. Workers Paid starts at $5 a month with 10 million requests and 30 million CPU milliseconds included, while an EKS control plane alone is $0.10 an hour before nodes. Kubernetes becomes cheaper on sustained load, roughly above 57% average node utilization in our AWS comparison, and when you can use your existing cloud commitments.

Do I need a DevOps engineer to run a Kubernetes backend after leaving Cloudflare?

Not if a platform operates the cluster for you. Qovery runs deployments, ingress, TLS, preview environments and cluster upgrades on Kubernetes in your own AWS, GCP, Azure or Scaleway account, so a backend team can own production without a dedicated platform engineer. With raw EKS, GKE or AKS, plan for at least part of one engineer's time on upgrades and tooling.

Can I keep Cloudflare in front of the new backend?

Yes, and I recommend it. Keep Cloudflare DNS, CDN, WAF and edge Workers for routing or auth, and point the proxied hostname at your Kubernetes ingress as the origin. The cutover becomes an origin change your users never see.

Alessandro Carrano
About the author
Alessandro Carrano

Alessandro leads product at Qovery. He drives the changelog, roadmap, and product strategy - turning customer feedback into platform capabilities.

Next step

Run your backend and database in your own cloud account.

Qovery deploys your API, workers and managed databases on Kubernetes in your own AWS, GCP, Azure or Scaleway account, or your existing cluster. Free plan: 3 users, 1 cluster of your own, no credit card.