Where to Run Your Backend in 2026: Moving Past Serverless Timeouts Across Vercel, Render, Fly.io, and Unified MicroVM Clouds

Contents
The frontend deploys in ninety seconds and the backend is where the architecture decisions ambush you. Every team we talk to hits the same sequence: a Next.js app goes up on a CDN-fronted platform without incident, then the first real job appears, a video transcode, an import, an agent loop, a webhook consumer, and the job dies at a wall clock limit nobody chose. This post is a map of that wall in 2026: where it stands on each platform, how far it has moved, and which side of it your workload belongs on.
The numbers are from vendor documentation checked on 7 November 2026, cited inline, and the usual disclosure applies: we operate one of the platforms in the survey, it goes in the comparison rather than above it, and where a competitor has closed a gap we say so.
The wall, measured
On Vercel, functions default to a 300-second maximum duration. Hobby caps at 300 seconds. Pro and Enterprise cap at 800, generally available, and an extended maximum of 1,800 seconds is in beta for supported Node, Bun and Python runtimes, configured per function rather than as a project default. On AWS Lambda, the function timeout is 900 seconds, and AWS documents the service as “designed for short-lived compute tasks that do not retain or rely upon state between invocations”. Both numbers are the contract of request-driven compute rather than a defect: an invocation has a deadline, and everything you build inherits it.
What the deadline breaks, in rough order of how often teams discover it: WebSocket consumers and stream readers, because a held connection is an invocation that never returns. Batch work over large datasets, because the job does not fit in fifteen minutes and checkpointing to a queue is a rewrite, not a config. Migrations and nightly jobs that touch every row. Retry loops with backoff that outlive their trigger. And agent runtimes, which are the new case: an agent deciding to call nine tools, waiting on an LLM, branching on the answer, is a long-lived stateful process even when each individual step is short.
To Vercel’s credit, the wall has doors now
Two years ago the answer to “long-running backend on Vercel” was a flat no. That is stale, and saying so is the only honest way to write this section. The platform’s own guidance for background workers now lists waitUntil for work that outlives the response, Cron Jobs for schedules, Queues (beta) for at-least-once delivery, Workflows for durable executions that “pause, resume, and maintain state for minutes to months without duration limits”, Sandboxes for isolated long-running compute, and Daemons (beta) for the always-on process shape itself. WebSocket connections are served natively in public beta. The pricing page meters all of it: Fluid compute at $0.128 per active CPU-hour plus $0.0106 per GB-hour of provisioned memory, Daemons at the same CPU rate with memory at $0.0212 per GB-hour, Sandbox at $0.128 per CPU-hour.
Two structural notes survive all of that. The extended duration above 800 seconds is beta, per-function, and tied to supported runtimes and networking configurations, which is a fine product boundary and still a boundary. And the pricing page lists Blob storage, Drives, Queues and a container registry, with no managed relational database: the state layer of a Vercel-centered stack is a second vendor’s product on a second bill, by design. Whether that is a cost or a feature depends on how many vendors you want to hold, which is the same question our serverless Postgres survey turns on.
The four shapes of backend work
Almost every “where do I run this” question resolves once you name the shape.
Request-driven. In, compute, out, inside a few seconds. This is what function platforms are built for, and on this shape Vercel, Lambda and our own Scalix Functions all bill close to zero when idle. Keep it here. Nothing below is an argument for moving work that already fits.
Scheduled. Cron triggers, nightly jobs, report generation. Every platform surveyed sells a cron primitive, Render’s billed per minute from $0.00016, Vercel’s included, ours at $1.10 per million executions plus $0.09 per job-month. The only question is whether the job fits inside a function duration; if it does not, it is shape three wearing a costume.
Long-lived processes. Queue consumers, WebSocket servers, stream processors, agent loops, anything holding a socket or a while-loop open. This is the shape that needs an always-on home: a process with a lifetime, billed by the second or the month, that survives between requests. Every platform below except pure-function ones sells it.
Stateful ephemeral compute. Sandboxes for generated or untrusted code, per-session environments, notebooks. Youngest category, and now sold by Vercel, Render, Railway, AWS and us. What separates the offerings is less the API than the isolation story, which is the subject of what is a microVM and not re-argued here.
Where each platform hosts the long-lived shape
Render is the flat-rate reading of the answer. A background worker is a first-class service type at the same published prices as web services, from $7 per month for 0.5 CPU / 512 MB, and paid types never spin down, which is a defect for idle-heavy workloads and exactly the point for workers. Predictable bill, deep managed data services beside it, no per-second surprises.
Fly.io sells the machine itself. Machines start and stop through an API at subsecond speeds, billing per second while running and $0.15 per GB-month of root filesystem while stopped, so a worker that is awake twelve hours a day pays for twelve hours. The control is the product; the assembly is yours.
Railway meters per second against plan credits, $20 per vCPU-month and $10 per GB-month at published rates, and sleeps services after ten minutes without outbound packets. For a worker, read that sleep rule carefully: Railway’s docs exclude inbound traffic from the wake calculus and warn the first request after sleep “may return a 502”, so a consumer that only receives work is a candidate for surprise naps unless it is pinned awake.
AWS runs long-lived processes as ECS tasks on Fargate or EC2, at the rates torn down line by line in the production stack cost post, with the network furniture that teardown prices. Lambda handles up to fifteen minutes and no longer, and the newer Lambda MicroVMs product pushes durable executions to eight hours for workloads built against that API.
Vercel now answers with Daemons (beta) and Workflows, priced above. It is a real answer with a beta label on the process-shaped half of it.
Scalix Run, ours, is a container service on dedicated-kernel microVMs where the long-lived shape is the default rather than the exception: a worker is a deployment with --min-instances 1, billed per second at $0.036/vCPU-hour and $0.004/GiB-hour while awake, parkable to zero when it is not, with health-gated deploys and one-command rollback. The argument for it is adjacency rather than rate: the Postgres the worker consumes from (Nova, 16/17/18 with branching and point-in-time recovery), the object storage it writes to, the auth in front of it and the inference it calls are the same key and the same usage ledger, which is the whole thesis of one key, one bill. The limits are the ones we publish: one EU region with India next, 4 vCPU per service, no support tiers on paper.
The always-on worker, priced
Same reference worker everywhere, 0.5 vCPU and 1 GB of memory, awake for the whole 730-hour month, vendor rates of 7 November 2026:
| Platform | Rate shape | Monthly |
|---|---|---|
| Render | flat instance (0.5c / 512 MB) | $7.00 |
| Fly.io | shared-cpu-1x 1 GB, per second while running | $6.70 |
| Railway | $20/vCPU-mo + $10/GB-mo against Pro credits | $20.00 |
| AWS Fargate | $0.0405/vCPU-hr + $0.00445/GB-hr | $18.02 |
| Scalix Run | $0.036/vCPU-hr + $0.004/GiB-hr | $16.06 |
| Vercel Daemons (beta) | $0.128/CPU-hr + $0.0212/GB-hr | $62.20 |
| AWS App Runner | $0.064/vCPU-hr + $0.007/GB-hr provisioned | $28.47 |
Two honest readings. First, the Vercel number is not an indictment; Daemons price active CPU like a premium product because the platform’s centre of gravity is elsewhere, and a worker that idles most of the day costs far less under Fluid’s active-CPU meter than this always-on row suggests. Second, the cheap rows are cheap because the shape is small: at 4 vCPU and steady load the flat-rate platforms stop scaling linearly while per-second meters keep doing exactly that, and the ranking reshuffles. Price your own duty cycle, not ours.
The agent-backend case, because it is 2026
The workload that stress-tests every platform in this post is an AI agent runtime, and it is worth naming why. An agent loop is shape three, long-lived, with a twist: the code it runs was written seconds ago, by a model, on purpose. That combination, long lifetime plus unreviewed code, is the exact case where the isolation boundary stops being an architecture preference. A shared-kernel container running reviewed application code is good isolation for almost everything; a process executing runtime-generated shell commands on the same kernel as its neighbours is a different risk class, which is why sandbox-shaped products with per-workload kernels now appear on the pricing pages of Vercel, Render and Railway, and in AWS’s serverless lineup.
We run this stack against ourselves, unflatteringly and publicly: agents that operate our own cloud over MCP provision database branches, deploy containers and read back their own spend, with generated code confined to ephemeral sandboxes. The operational lessons are in how an agent operates a cloud, and the short version is that the platform requirements are: durable processes, per-workload kernels, stateful services beside the agent rather than across the internet from it, and a billing surface the agent itself can read. If you are choosing hosting for an agent product, those four requirements will outlive any single vendor’s current beta lineup.
Picking, in one paragraph
Request-driven work stays on functions, wherever your frontend lives. Scheduled work stays on cron unless it outgrows a duration, at which point it is a worker. Workers and sockets and agent loops go to an always-on process platform: Render for the flat bill, Fly for machine-level control, Railway for usage-shaped pricing on owned hardware, AWS if the estate is already there, Vercel’s Daemons if the whole stack lives there and beta is acceptable, Scalix Run if the worker’s database, storage, auth and inference should sit on the same key and the same ledger in the EU. Sandboxed generated code goes to whichever of those publishes an isolation boundary you would sign in front of your security team. That is the whole decision, and every number to make it concrete is cited above.
If your shape landed on our row and you want to test the claim rather than the marketing, Scalix Run deploys a worker from a source directory or an image, the database beside it is one API call away, and the rates are the published price book. If your shape landed somewhere else, that is a good outcome and this post did its job. Either way, come tell us what you measured on Discord.
FAQ
Can Vercel host a long-running backend?
Partly, and increasingly. Functions cap at 300 seconds by default, 800 seconds maximum on Pro, with a 30-minute extended maximum in beta that requires per-function configuration and supported runtimes. Beyond that, Vercel's own guidance routes work to Queues, Workflows (which allow pause and resume without duration limits), Cron, waitUntil, Sandboxes or Daemons, the last of which is in beta. What the pricing page does not list is a managed relational database, so state lives with a second vendor.
Where should I run long-running background jobs in Next.js?
Match the job to the primitive. Jobs that finish in seconds belong in functions with waitUntil. Scheduled jobs belong in Cron. Jobs that must survive restarts and retry belong in a queue or workflow product. Jobs that hold a socket open, consume a stream, or run an agent loop for minutes at a time belong in an always-on process: a Render worker, a Fly Machine, a Railway service, or a container on a microVM platform like Scalix Run. The mistake is forcing the fourth shape into the first primitive.
What is a Vercel function timeout alternative?
Three real options. Split the work: a function enqueues, an always-on worker consumes. Delegate the duration: Vercel Workflows exist precisely for code that pauses and resumes over minutes to months. Or move the worker: run the long-lived process on an always-on platform and keep the frontend where it is, accepting one more vendor and one more credential. Teams that serve the frontend from a CDN and run workers on Scalix Run, Render or Fly are doing the third option, and the honest cost is the seam between the two.
What does AI agent backend hosting actually require?
Four things most function platforms were not shaped for: executions that last minutes to hours rather than seconds, durable state between steps, a database and object storage the agent can reach with the same credential, and isolation strong enough for code the agent wrote at runtime. The last one is why agent sandboxes are their own product category now, on Vercel, Render, Railway, AWS and ours.
Is it cheaper to run workers on functions or on an always-on instance?
It crosses over with duty cycle. A worker busy a few minutes a day is nearly free on functions and pays full freight on an always-on instance. A worker busy more than a few hours a day inverts that: our 0.5 vCPU / 1 GB reference worker costs $62.20 per month on Vercel Daemons beta rates against $7 flat on Render or $16.06 on Scalix Run. Model your own duty cycle before believing either number.