WebSocket and Background Worker Support Across PaaS Platforms

WebSocket support and background worker capability split the PaaS market cleaner than any pricing sheet ever will. Persistent-process requirements knock out an entire class of platforms before pricing, developer experience, or anything else even enters the conversation. This piece walks through how the major platforms actually handle these workloads, so the choice of platform matches what the app actually needs to run. WebSocket and Background Worker Support Across PaaS Platforms is examined.

Persistent processes as the first filter

Most comparisons start with a price chart or a screenshot of the dashboard. Starting with a price chart or dashboard screenshot rather than the runtime model gets the comparison backwards. The real disqualifying question is about runtime model: does a process stay alive between requests, or does it die the moment the response goes out?

Think about what a normal web app actually does. It keeps a process running, talks to a database, chews through background jobs, and often holds a WebSocket or some other long-lived connection open for minutes or hours at a stretch GMI Cloud Opslyft. That one requirement, a process that outlives a single request, is enough to cut the PaaS landscape into two categories that don't overlap.

On one side: always-on platforms, where persistent processes, WebSockets, and background workers are native, expected, first-class citizens. On the other: serverless and edge platforms, built around the request-scoped function, no long-lived process anywhere in the model. Neither category is wrong. They're built for different shapes of application.

Check whether the app contains the phrase "and then, later". If a request kicks off work that needs to keep happening after the response is sent, or a connection needs to stay open past the length of one HTTP call, the app belongs in the always-on category. Once that's settled, the rest of the comparison actually becomes useful instead of just noise.

What serverless and edge runtimes cannot do

Four constraints push a workload off edge and serverless runtimes, and they're not edge cases, they're structural: a CPU time ceiling on every invocation, no support for native modules, limits on the database wire protocols a function can speak to, and no way to hold long-lived state or connections between calls.

Vercel is the clearest example. As of February 2026, it can't run persistent processes or background workers. Native WebSocket support did arrive in public beta that June, but connections still get capped by function duration limits, so full-stack apps that need both a frontend and a stateful backend end up split across more than one platform. Those are common, everyday numbers. They're a ceiling sitting over every job the platform runs GMI Cloud SpendArk Opslyft 10 Best PaaS Providers for Web Apps in 2026 | seenode blog. The beta WebSocket support helps, but connections are still tied to a function's lifecycle, so real-time apps built on it need solid reconnect handling and some external service to hold state the function itself can't.

Cloudflare Workers runs on V8 isolates, and there's no long-lived process anywhere in that model. A WebSocket server, a background worker, an in-memory cache shared across requests, any job that needs to run past the current request, all of that assumes a process that outlives the request, which isn't how Workers is built. Durable Objects exist to patch over some of that coordination gap, but they mean learning a different programming model, not just deploying the same app differently⟧c13⟧.

None of this is an argument against serverless or edge platforms. It's an argument for using them where the shape fits: static sites, APIs that do one thing and return fast, frontends that don't need a persistent backend riding shotgun. The next section covers where the fit runs the other way. Netlify offers no long-running persistent server processes, though managed databases, background functions, and scheduled functions (cron jobs) are available as first-party platform primitives, a relevant caution when it appears in "Vercel alternative" lists for backend-heavy apps. Vercel billing complexity presents a secondary concern, with multiple simultaneous meters including bandwidth at $40/100GB overage, function invocations at $0.18/GB-hour, and edge middleware charges GMI Cloud 10 Best PaaS Providers for Web Apps in 2026 | seenode blog.

How the always-on platforms handle WebSocket connections

"Always-on" sounds like one category, but the platforms inside it behave quite differently once a connection has to stay open for a while.

Render has the best-documented story here. It doesn't impose a fixed WebSocket duration at all, though a deployment or an instance getting replaced will still drop connected clients. Railway publishes a full Socket.IO workflow and makes it fast to get a real-time app running, but every connection is still subject to a 15-minute request limit, which matters a lot if the app depends on connections staying open longer than that. Fly.io was built with globally distributed WebSocket servers in mind: its proxy routes traffic to nearby Machines and can balance load by concurrent connection count, which makes it the strongest pick when users are spread across regions and latency actually matters. Heroku supports WebSockets too, with optional HTTP session affinity across dynos, a mature and well-understood setup, though the platform itself is now in a maintenance-focused posture as of February 6, 2026.

Even the always-on platforms have duration limits and deployment-triggered disconnects baked in somewhere, so "always-on" never really means zero interruption. Client-side reconnect logic isn't optional just because the platform advertises persistent connections. Before picking one, it's worth checking not just whether WebSockets are supported, but what happens to an open connection the moment a deploy goes out.

Background workers and long-running jobs on always-on platforms

Render treats background workers as a first-class thing that can run continuously, including tasks that take a genuinely long time.

Railway leans on managed databases and private networking between services to make worker and queue patterns straightforward to wire up. Fly.io handles workers the same way it handles web services: each one is a Machine, billed per second, at roughly $0.0000022 per second for a shared-cpu-1x-256mb instance. There's no separate worker tier, just the same unit priced the same way.

SnapDeploy explicitly supports WebSocket servers, background workers, cron jobs, and services with native system dependencies; free containers auto-sleep after 45 minutes, and always-on service starts at $12 a month per container.

The real dividing line, once you sort through all of this, is whether a platform treats workers as their own distinct process type (Heroku, Render) or just as another instance of a service (Railway, Fly.io). That distinction shapes how queuing, scaling, and billing end up interacting once the app is actually running in production. Heroku supports worker dynos as a distinct process type, priced in the same $5–$500/month per dyno range, with autoscaling only available on Performance-, Private-, and Shield-tier dynos, billed at the peak of the scaling window.

Platform-by-platform feature map for teams choosing on persistent-process requirements

Render's tiers run Starter at $7 a month, Standard at $25, Pro at $85, with Postgres from $7 (256MB) up to $95 (4GB) and Key-Value starting at $10. Free web services spin down after 15 minutes idle, free Postgres expires after 30 days, and there's no fixed WebSocket duration limit, with both background workers and Workflows supported.

The 15-minute request limit on connections still applies, the Socket.IO workflow is documented, and moving a database over from Heroku is a matter of pg_dump and pg_restore.

Fly.io costs about $0.0000022 a second for a shared-cpu-1x-256mb Machine, roughly $1.94 a month, and scales by adding Machines rather than resizing one big instance. Fly Postgres starts at that same $1.94 baseline, WebSocket routing is distributed globally by concurrent connections, and the baseline plan includes three of those shared-cpu Machines.

WebSockets work with optional session affinity, worker dynos are a first-class process type, autoscaling is Performance-tier only, and the platform is in a maintenance-focused posture as of February 6, 2026.

SnapDeploy's free tier gives 4 containers and 512MB RAM with auto-sleep after 15 minutes, and always-on service runs $12 a month per container. It supports WebSocket servers, background workers, cron jobs, and native system dependencies, though there's no free database included.

Cloudflare Workers and Pages run on the edge/isolate model, with no persistent process, Durable Objects used for coordination only, and neither is suited to running a traditional WebSocket server or background worker.

Google Cloud Run rounds this out differently: it deploys any Docker container, so REST APIs, full web servers, and background workers all run on it, it scales to zero when idle, and it plugs into Cloud SQL and Cloud Build. The free tier includes 180,000 vCPU-seconds a month, though it does ask for a credit card and some working familiarity with GCP to set up. Vercel is serverless only, with beta WebSocket support tied to function lifecycle, function timeouts of 10s / 60s / 300s by plan, and is not suitable for persistent workers without external services.

Billing model as a hidden variable in always-on workload cost

The billing model matters just as much as the feature list, and it is easy to miss until the invoice reveals it.

Fixed-tier billing, the kind Render and seenode use, is predictable for a worker that's supposed to run around the clock: it costs the same whether it processes 10 jobs that month or 10,000 10 Best PaaS Providers for Web Apps in 2026 | seenode blog. Nothing weird appears at the end of the billing cycle. Usage-based billing, Railway's $0.000231/GB-hr plus $0.000463/vCPU-hr, or Fly.io's $0.0000022 a second, can come out cheaper for something bursty or lightly used, but it keeps accumulating nonstop for a queue consumer that's always running.

Heroku's autoscaling is limited to Performance dynos and bills at the peak of the scaling window, so teams pay for provisioned capacity rather than consumed capacity; Railway and Fly.io's per-second billing models are more efficient for autoscaling workloads. Vercel adds its own wrinkle: bandwidth overage at $40 per 100GB, function invocations at $0.18 per GB-hour, plus edge middleware charges on top, all running simultaneously, which compounds fast for any app trying to fake persistent behavior through repeated function calls.

The rule of thumb holds up under most scenarios: fixed tiers win when a worker runs steady, all day, every day. Usage-based billing wins when traffic is bursty or the worker mostly sits idle. Model both before signing up, not after the first invoice lands.

Heroku's maintenance posture and its meaning for persistent-process workloads

Heroku said, as of February 6, 2026, that its focus going forward is stability, security, reliability, and support, not new features. That's a direct signal: nothing new is coming for WebSocket handling or worker support. The free tier disappeared back in 2022, and prices have gone up twice since then, so the platform's economics have moved in the opposite direction from what teams originally signed up for.

Moving to Render is the closer of the two common paths. Its service model mirrors Heroku's fairly closely, and it offers Cloud Native Buildpacks auto-detection as a build option, which covers most common Heroku setups, though it isn't directly compatible with Heroku's classic buildpack API, so some build configuration will need adjusting during the move. Moving to Railway tends to go faster, often finishable within a day for most apps. Railpack, which replaced Nixpacks as Railway's default build system in March 2026, auto-detects the buildpack straight from the Git repo, and the database moves over with a standard pg_dump and pg_restore.

Migrating just the Postgres database to Supabase while leaving compute where it already sits on Heroku or Railway often saves more money than moving the whole app, and there's a tool, heroku-cost-calculator, that models exactly this with a postgres_only_migration flag.

None of this breaks anything for a team running WebSocket servers or background workers on Heroku right now. But the signal is clear: whatever comes next for worker scheduling, connection handling, or autoscaling isn't coming from Heroku, and that's worth weighing against how much the app is expected to grow.

Persistent workloads in your own cloud account

Every shared PaaS, Railway, Render, Fly.io, Heroku, controls its own infrastructure migration schedule. Workloads move when the platform decides to move them, on a date the platform sets. That's simply how shared-tenant infrastructure works for any one of them. It's just how shared-tenant infrastructure works.

For teams carrying compliance requirements like SOC 2 or HIPAA, data residency rules, or a general need for infrastructure control alongside their always-on workloads, that shared-tenant model creates a ceiling no amount of new features will ever lift. A PaaS that deploys directly into the team's own AWS, GCP, or Azure account, running persistent processes, WebSocket servers, and background workers inside infrastructure the team actually owns, while keeping the same simple Git-deploy workflow a shared platform offers.

This route needs a cloud account already set up and a bit more upfront configuration than clicking deploy on a shared platform. What it buys back is infrastructure control, a compliance posture that actually holds up to an audit, and cost economics that scale with the business itself rather than with whatever pricing model the platform happens to run this year.

The decision isn't complicated once the requirements are actually named. A small team building something that needs persistent processes should start on a shared always-on platform, full stop. Compliance, scale, or the risk of not controlling the platform becomes the binding constraint that makes the move to a cloud account of the team's own the right call, and at that point it becomes the next expected step rather than a gamble.