Best app deployment platforms in 2026: 87 compared

The app-hosting market no longer has one clean ladder from shared hosting to a virtual server. It has at least seven different products hiding behind the same promise: connect a repository and ship.

A Vercel deployment can be static files plus framework-aware functions. A Railway project can be several continuously metered containers and a database. A Cloud Run service can scale an ordinary container to zero. A Fly.io app is a set of micro-VMs that may carry local volumes. A Supabase project is a backend platform, not the web origin. Coolify is software you install on a server you still have to operate.

Those differences are not implementation trivia. They determine idle cost, cold starts, maximum request duration, filesystem behavior, network egress, database reliability, spend risk, and how difficult it will be to leave.

This guide compares 87 current deployment products and tools commonly considered by hobbyists, indie hackers, solopreneurs, agencies, and small product teams. It covers frontend clouds, static hosts, edge functions, container PaaS, scale-to-zero containers, event functions, workflow runtimes, managed open-source hosting, bring-your-own-cloud platforms, and self-hosted PaaS.

Central finding: there is no universal winner. Vercel Pro is the lowest-friction commercial Next.js choice. Cloudflare Workers and Static Assets are the strongest low-cost edge/static default. Railway is the most approachable usage-metered full-stack PaaS. Render is useful for evaluation but its free services are deliberately constrained. Google Cloud Run is the best mainstream portable scale-to-zero container reference. Fly.io is compelling for globally distributed machines when the team can handle its state model. Coolify and Dokploy are the best cash-cost alternatives when running a VPS is acceptable. The cheapest platform is the one whose billing model matches the workload, not the one with the smallest number on its pricing page.

This article complements the 48-provider VPS comparison. A self-hosted PaaS can reduce platform fees, but it does not remove the CPU, memory, disk, traffic, backups, security, or administrative work described in that guide.

Prices and product status were checked against first-party provider material on July 23, 2026. Prices are before tax and can vary by region, currency, architecture, and account age.

Table of contents

• The answer in 60 seconds
• Scope and evidence
  • Evidence labels
• Serverless and serverful are not opposites
  • 1. Static and frontend clouds
  • 2. Request-metered functions and edge runtimes
  • 3. Scale-to-zero containers
  • 4. Always-on container PaaS
  • 5. Distributed machines
  • 6. Bring-your-own-cloud control planes
  • 7. Self-hosted PaaS and deployment tools
• The real monthly cost formula
  • When fixed pricing wins
  • When usage pricing wins
  • When one server wins
• The 22 traps that change the answer
  • 1. "Free" may prohibit commercial use
  • 2. A credit is not a dollar and not a resource
  • 3. The free tier may pause the whole account
  • 4. Sleep is not scale-to-zero
  • 5. A database rarely scales exactly like the app
  • 6. Local disks are not managed distributed storage
  • 7. "No egress" can be product-specific
  • 8. Bandwidth can be a credit meter
  • 9. Inbound traffic can count
  • 10. Build minutes are production cost
  • 11. Preview deployments duplicate services
  • 12. Seats and compute can stack
  • 13. Logs are not free observability
  • 14. A spend alert is not a hard limit
  • 15. Minimum instances defeat zero-idle economics
  • 16. Concurrency changes price and latency
  • 17. Serverless databases have their own wake and connection model
  • 18. A load balancer can cost more than compute
  • 19. Static IPs and private networking cost money
  • 20. A platform shutdown is a pricing event
  • 21. "Open source" does not equal free operations
  • 22. Framework portability is not runtime parity
• Full market map: 87 deployment options
  • Frontend, static, and edge platforms (16)
  • General PaaS and managed application/container platforms (32)
  • Serverless containers, functions, AI, and durable workflow runtimes (20)
  • BYOC and self-hosted deployment platforms (19)
• What free really means
• Egress and bandwidth compared
  • Four network questions to ask
  • Why the lowest per-GB rate is not automatically best
• Major platform analysis
  • Vercel: best commercial Next.js experience, not the cheapest generic backend
  • Netlify: the closest broad frontend workflow, with a credit abstraction
  • Cloudflare Workers and Static Assets: strongest low-cost edge/static default
  • Deno Deploy: credible web-standard serverless, with a recent product boundary
  • Railway: best approachable full-stack usage-metered PaaS
  • Render: useful free evaluation, clear paid PaaS
  • Fly.io: best control and placement among small-team platforms
  • Heroku: mature and supported, but now a roadmap decision
  • DigitalOcean App Platform: best predictable small paid service in a familiar cloud
  • Koyeb: attractive low-use global containers, with persistence caveats
  • Northflank: strongest small-team service graph after Railway
  • Back4app Containers: unusually clear fixed small plans
  • Leapcell: flexible, but every meter matters
  • Replit Deployments: best integrated editor-to-launch workflow
  • Bunny Magic Containers: important new global container alternative
  • Firebase App Hosting and Amplify: integrated clouds, integrated bills
  • Laravel Cloud, Forge, and Vapor: one ecosystem, three different operating models
  • Framework-specialist platforms are often better than a generic PaaS
• Serverless containers and functions
  • Google Cloud Run is the reference portable serverless container
  • Azure Container Apps is the Azure equivalent with jobs
  • IBM Code Engine and Scaleway are credible alternatives
  • AWS Lambda remains excellent for events, not universal hosting
  • AWS ECS Express Mode is not the new free App Runner
  • Modal, Val Town, and Upstash Box solve different problems
  • Trigger.dev, Inngest, and Pipedream are complements
• Self-hosted and bring-your-own-cloud alternatives
  • Coolify: best general self-hosted default
  • Forge, Ploi, RunCloud, and CloudPanel: server control panels, not hosted compute
  • Cloudron: an app catalog and appliance-like server layer
  • Dokploy: best for Docker Compose and multi-server simplicity
  • Easypanel and CapRover: good one-server panels
  • Dokku and Kamal: fewer abstractions, more transparency
  • Kubero and OpenFaaS: only when Kubernetes is already justified
  • BYOC: ownership with a double invoice
• Backend and database companions
  • The split-stack advantage
  • The split-stack cost
• Lifecycle warnings
• Cost scenarios
  • Scenario 1: static commercial marketing site, 20 GB/month
  • Scenario 2: one always-on 512 MB API, low traffic
  • Scenario 3: bursty API, 50,000 requests/month, 100 ms average CPU, no minimum instance
  • Scenario 4: 100 GB/month public delivery
  • Scenario 5: SaaS with frontend, API, Postgres, worker, cron, and previews
  • Scenario 6: GPU-backed AI demo
• Best platform by use case
  • Best Vercel alternative
  • Best Railway alternative
  • Best free commercial static hosting
  • Best tiny commercial API
  • Best background jobs
  • Best for Laravel and PHP
  • Best for Elixir, R, and WebAssembly
  • Best for Europe
  • Best for Spain
  • Best self-hosted PaaS
  • Best own-cloud platform
• Decision tree
  • Step 1: Is the output static after build?
  • Step 2: Does the application require a conventional long-running server?
  • Step 3: Can it scale to zero without harming user experience?
  • Step 4: Is persistent local disk required?
  • Step 5: How much outbound traffic will the app send?
  • Step 6: Is operating Linux acceptable?
  • Step 7: Does the infrastructure need to stay in your cloud account?
• Portability and migration checklist
  • Portability tiers
• Frequently asked questions
  • What is the best Vercel alternative in 2026?
  • Is Railway cheaper than Vercel?
  • Is Render really free?
  • Which platform has the cheapest egress?
  • Does serverless mean zero cost when idle?
  • Can a serverless platform run background workers?
  • What is the cheapest way to host many small apps?
  • Should a hobbyist use Kubernetes?
  • Which free tiers allow commercial projects?
  • Which platform is best for a small always-on API?
  • Which platform is best for Next.js?
  • Which is best for Laravel: Laravel Cloud, Forge, or Vapor?
  • Which platform is best for R and Python data apps?
  • Is a server management panel the same as a PaaS?
  • What is the difference between PaaS and BYOC?
  • Are platform databases cheaper than external databases?
  • How do I prevent a surprise serverless bill?
  • How often should this comparison be updated?
• Bottom line
• Official sources checked
  • Update policy

The answer in 60 seconds

The following are editorial fit judgments, not provider claims and not a universal performance benchmark.

Requirement	Editorial shortlist	Why it fits	Main reason not to choose it
Commercial Next.js with minimum friction	Vercel Pro	Best framework integration, previews, and operational ergonomics	Seat and multi-meter usage pricing; Hobby is non-commercial
Cheapest serious static or edge project	Cloudflare Workers + Static Assets	$5 paid account, free static delivery, no separate Workers egress	Runtime and product-specific limits; Containers have different egress rules
Full-stack side project with database	Railway Hobby	Simple service graph, templates, databases, logs, and usage billing	Always-on CPU/RAM and each database/service accumulate usage
Free PaaS evaluation	Render Free	Familiar Git deploy, web service, static sites, and temporary Postgres	15-minute sleep and 30-day free database expiry
Predictable tiny always-on API	DigitalOcean App Platform, Back4app, or Lightsail Containers	Fixed entry plans are easier to budget than many tiny usage meters	Less scale-to-zero benefit and product-specific transfer overage
Portable scale-to-zero container	Google Cloud Run	Standard container contract, strong autoscaling, jobs, and broad ecosystem	Egress, logging, builds, registry, minimum instances, and VPC extras
Global low-latency micro-VMs	Fly.io	Place machines close to users and run ordinary containers	Local volumes, multi-region state, and operational complexity
European serverless container	Scaleway Serverless Containers or Koyeb	European options with scale-to-zero behavior	Check current regional prices, volumes, and outbound terms
AI or bursty Python compute	Modal	Serverless CPU/GPU jobs, endpoints, images, and volume primitives	Not a conventional full-stack host; warm capacity and GPU choices matter
Tiny webhooks and automations	Val Town or Pipedream	Fast hosted execution with integrations and minimal infrastructure	Constrained runtimes and credit/run limits
Durable background workflows	Trigger.dev or Inngest	Retries, queues, schedules, observability, and long-running work	These complement rather than replace the main app host
Laravel or PHP product	Laravel Cloud, Forge, or Vapor	First-party managed platform, owned-server control plane, and AWS serverless path	They have fundamentally different infrastructure, idle, and billing models
One VPS, many indie apps	Coolify or Dokploy	Low control-plane cost and broad Docker/database support	You become responsible for the server and shared blast radius
Minimal self-hosted deploys	Kamal or Dokku	Transparent deployment with little platform abstraction	No managed database, backup, HA, or incident response by default
Own-cloud platform for a team	Porter, Qovery, Flightcontrol, or Cloud 66	PaaS workflow while resources stay in your account	Platform fee plus cloud minimums, networking, and operations

A practical first cut is:

1. Choose Vercel when the full Next.js workflow is worth a per-developer subscription and metered usage.
2. Choose Cloudflare when static delivery, edge logic, and low network cost matter more than a conventional Node server.
3. Choose Railway when the application is naturally several ordinary services and a database and you want usage visibility in one product.
4. Choose Render to evaluate a Heroku-like workflow without paying immediately, but move production workloads to paid resources.
5. Choose DigitalOcean App Platform, Back4app, Koyeb, Fly.io, or Lightsail Containers when a small always-on service is the actual workload.
6. Choose Google Cloud Run when scale-to-zero and a portable container contract are more important than the simplest invoice.
7. Choose Coolify, Dokploy, Easypanel, CapRover, Dokku, or Kamal when a VPS-backed stack is acceptable and operational work is understood.

Scope and evidence

"All services" cannot literally mean every regional host, one-person wrapper, cloud reseller, Kubernetes distribution, discontinued product, or private beta. This comparison uses a reproducible boundary:

• Products must be publicly documented and globally or multi-region marketed.
• They must provide application deployment, static/edge execution, container/function execution, a BYOC control plane, or a commonly used self-hosted launch workflow.
• They must be plausible for an individual or small team, even if higher tiers later target enterprises.
• Raw VPS providers are linked to the separate VPS article rather than repeated here.
• Databases, auth systems, queues, and workflow engines that cannot replace the main app host are listed as companions rather than misclassified as universal hosting.

Evidence labels

Verified facts in this article are public plan prices, quotas, commercial-use wording, lifecycle notices, and documented product behavior from first-party sources.

Accepted technical consensus covers principles such as immutable deployments, the risks of local persistent disks in multi-region systems, and the fact that cold starts, connection pools, and concurrency affect serverless performance.

Editorial inference appears in recommendations and fit judgments. It combines published product behavior with workload economics. It is not a provider benchmark.

Speculation is avoided. Where official material conflicts or a live calculator prevents a durable quote, the conflict is stated instead of resolved by guesswork.

The guide also avoids a fake universal speed ranking. Region, framework, image size, database distance, cache ratio, cold/warm state, concurrency, CPU allocation, and test date can reverse a benchmark result.

Serverless and serverful are not opposites

The useful distinction is not whether a provider uses servers. Every product does. The useful question is what resource the customer reserves and what event causes a charge.

1. Static and frontend clouds

Static files are built once and served from an edge cache. Dynamic behavior comes from functions, middleware, SSR, image optimization, or an external backend. Examples: Vercel, Netlify, Cloudflare Pages/Static Assets, GitHub Pages, Surge, Sevalla Static.

Best for: documentation, marketing sites, SPAs, cached commerce frontends, and framework apps whose backend is small.

Failure mode: assuming the static-site price also covers heavy SSR, image transformation, builds, logs, and data transfer.

2. Request-metered functions and edge runtimes

Code runs for an invocation and generally disappears afterward. Examples: Cloudflare Workers, AWS Lambda, Azure Functions, Cloud Run functions, Val Town.

Best for: webhooks, authentication callbacks, lightweight APIs, scheduled tasks, event handlers, and middleware.

Failure mode: forcing long jobs, large native dependencies, stable TCP connections, or stateful processes into a short-lived runtime.

3. Scale-to-zero containers

The platform accepts an ordinary container, starts instances when needed, and may reduce instances to zero. Examples: Google Cloud Run, Azure Container Apps, IBM Code Engine, Scaleway Serverless Containers, portions of Koyeb and Leapcell.

Best for: portable HTTP services, bursty APIs, background jobs, and teams that want a container exit path.

Failure mode: adding a minimum replica, VPC connector, load balancer, NAT, log sink, registry, and database, then calling the result "zero-cost at idle."

4. Always-on container PaaS

The platform continuously allocates CPU and memory or charges for a fixed service size. Examples: Railway, Render paid services, DigitalOcean App Platform, Heroku, Back4app, Lightsail Containers.

Best for: ordinary web servers, workers, WebSockets, predictable latency, and applications that remain busy.

Failure mode: paying 730 hours for several nearly idle services when one small server or scale-to-zero container would suffice.

5. Distributed machines

The platform exposes VM-like machines with fast start/stop and regional placement. Fly.io is the clearest small-team example.

Best for: ordinary containers close to users, custom networking, and architectures that need more control than functions.

Failure mode: treating local disks as a globally replicated database or assuming autostop eliminates volume and address charges.

6. Bring-your-own-cloud control planes

The deployment company manages configuration, CI/CD, or Kubernetes while the workload stays in the customer's AWS, Azure, GCP, Scaleway, or VPS account. Examples: Porter, Qovery, Flightcontrol, Cloud 66, Encore, SST.

Best for: ownership, compliance, cloud credits, and reducing black-box lock-in.

Failure mode: adding a platform subscription to a cloud architecture with load balancers, NAT gateways, managed clusters, logs, and egress that already exceeds the cost of a bundled PaaS.

7. Self-hosted PaaS and deployment tools

You install a control plane or deploy directly onto servers. Examples: Coolify, Dokploy, Easypanel, CapRover, Dokku, Kamal, Kubero, OpenFaaS, Piku.

Best for: many small apps, predictable cash cost, custom networking, and full control.

Failure mode: counting only the VPS invoice while assigning no value to patching, backups, monitoring, restore tests, security, and incidents.

The real monthly cost formula

A useful all-in formula is:

monthly cost = platform and seat fees + active compute + idle/reserved compute + builds + database + storage and I/O + public egress + cross-zone/inter-region traffic + logs/metrics + outbound IP/NAT/load balancer + backups + support + tax

The formula explains why two "free" products can have opposite economics.

A static site on Cloudflare can genuinely remain near zero because static delivery has no server process and Workers traffic does not carry a separate egress fee. A nominally free full-stack project can still need a paid database, object storage, transactional email, log retention, and a commercial plan.

At the other end, a $5 Coolify control plane can run dozens of small apps, but the server, off-site backups, object storage, monitoring, and administrator time are not included in that $5.

When fixed pricing wins

Fixed small plans tend to win when the service is continuously active, needs predictable latency, or pushes a known amount of traffic. A $5 Back4app or DigitalOcean service may be cheaper and easier to reason about than a per-second platform for an always-on loop.

When usage pricing wins

Usage pricing tends to win when the workload is idle most of the time, bursty, or short-lived. Cloud Run, Workers, Lambda, Modal, and event/workflow services can run a low-volume project for very little - provided databases, logs, and minimum capacity do not become the floor.

When one server wins

One VPS can win when many small services fit safely together and the owner can operate Linux. It loses when one noisy workload, disk failure, compromised service, or bad deployment affects everything on the machine.

The 22 traps that change the answer

1. "Free" may prohibit commercial use

Vercel Hobby is explicitly personal and non-commercial. GitHub Pages says it is not intended as free hosting for an online business, ecommerce site, or SaaS. alwaysdata Free is for personal use. A price of $0 is irrelevant when the planned use is outside the offer.

2. A credit is not a dollar and not a resource

Netlify credits cover bandwidth, compute, requests, and production deploys. Replit credits cover deployment usage. Railway includes dollar-denominated usage but the minimum subscription does not make usage unlimited. A workload estimate has to be translated into the provider's unit.

3. The free tier may pause the whole account

Some credit systems suspend or pause multiple projects when a shared account pool is exhausted. Account-wide limits are riskier than project-level hard caps.

4. Sleep is not scale-to-zero

A sleeping free service may wake in about a minute and may not be suitable for production. Scale-to-zero is an intentional paid compute behavior with defined startup and billing semantics. Render Free sleep and Cloud Run scale-to-zero solve different problems.

5. A database rarely scales exactly like the app

The web process can reach zero while Postgres, Redis, object storage, backups, or a connection pool remains billable. A serverless frontend with an always-on database has an idle floor.

6. Local disks are not managed distributed storage

Fly volumes, preview/local volumes, and self-hosted Docker volumes can be excellent, but they are attached to a location or node. Replication, failover, backups, and restore procedures are separate design decisions.

7. "No egress" can be product-specific

Cloudflare Workers has no separate egress charge. Cloudflare Containers has regional egress pricing after included allowances. A company-wide slogan cannot safely be applied to every product.

8. Bandwidth can be a credit meter

Netlify charges credits per GB. A site can have a nominal plan allowance but consume it with builds, requests, or compute before all implied bandwidth is available.

9. Inbound traffic can count

Lightsail transfer allowances count inbound and outbound toward the allowance even though only outbound overage is charged. Leapcell can meter large ingress payloads. Read the direction rules.

10. Build minutes are production cost

A monorepo that triggers many preview builds can consume more than the runtime. Netlify production deploys consume credits; Amplify bills build minutes; Firebase App Hosting invokes Cloud Build and artifact storage; CI minutes can matter on GitLab Pages.

11. Preview deployments duplicate services

A frontend preview may be almost free, but a full preview environment with database, worker, cache, and search can multiply resources. BYOC platforms and composable PaaS products differ in whether previews share or duplicate infrastructure.

12. Seats and compute can stack

Vercel, Encore, Flightcontrol, and team plans can charge users or seats in addition to runtime. A five-person team with a tiny app can spend more on access than compute.

13. Logs are not free observability

Request logs, build logs, traces, metrics, retention, ingestion, and export are separate resources on many platforms. Serverless architectures can generate many small log events and high-cardinality traces.

14. A spend alert is not a hard limit

Some providers notify after cost has accrued. Others support hard budgets but can pause production. Test the exact behavior before launch.

15. Minimum instances defeat zero-idle economics

One minimum Cloud Run instance, one kept-alive Upstash Box, one paid web dyno, or one always-on Railway service establishes a monthly floor.

16. Concurrency changes price and latency

Higher concurrency can reduce instance count but increase tail latency, memory pressure, and connection contention. Low concurrency can improve isolation but trigger more instances and cold starts.

17. Serverless databases have their own wake and connection model

A scale-to-zero Postgres service can add wake latency. A high-concurrency function fleet can exhaust connection limits unless pooling is used.

18. A load balancer can cost more than compute

AWS ECS/Elastic Beanstalk/Flightcontrol examples often need an ALB. A tiny Fargate task can be inexpensive while the load balancer and NAT gateway set the real floor.

19. Static IPs and private networking cost money

Dedicated egress IPs, NAT gateways, private endpoints, VPC connectors, and cross-zone traffic are common hidden line items.

20. A platform shutdown is a pricing event

Migration labor is part of lifetime cost. App Runner stopped accepting new customers, Deno Deploy Classic shut, Shuttle ceased, Glitch ended hosting, and Flightcontrol is presenting a successor. Portability has economic value.

21. "Open source" does not equal free operations

Coolify, Dokploy, CapRover, Dokku, Kamal, Kubero, and OpenFaaS remove or reduce license fees. They do not operate the server, secure the database, or restore data after a failure.

22. Framework portability is not runtime parity

A Next.js app can build on multiple platforms but image optimization, ISR, middleware, cache invalidation, streaming, edge runtime, and preview behavior may differ. Test the features actually used.

Full market map: 87 deployment options

Frontend, static, and edge platforms (16)

Platform	Workload model	Public entry signal	Idle/scaling	Network model	Main catch
Vercel	Frontend cloud plus functions	Hobby $0; Pro $20/developer/mo with $20 usage credit	Static and functions scale automatically	Hobby 100 GB and Pro 1 TB transfer in the checked plan matrix; Pro overage $0.15/GB	Hobby is personal and non-commercial; seat and usage meters can stack
Netlify	Frontend cloud plus functions	Free $0/300 credits; Personal $9/1,000; Pro $20/3,000	Functions are on-demand; static delivery is edge-cached	Bandwidth consumes 20 credits/GB; requests, compute, and production deploys also consume credits	One credit pool covers multiple meters; exhausted credits can pause account projects
Cloudflare Workers	Edge functions and stateful primitives	Free; Paid starts at $5/account/mo	Request-driven; no always-on server process	No separate Workers egress or throughput charge; static asset requests are free	CPU, subrequest, runtime, storage, and product-specific limits still apply
Cloudflare Pages / Workers Static Assets	Static delivery plus Workers	Static asset delivery can be $0; dynamic code follows Workers pricing	Static by default; functions are request-driven	Static asset requests and Workers egress are not separately charged	It is not a persistent server; dynamic behavior inherits Workers limits
Deno Deploy	Edge/serverless JavaScript and TypeScript	Free $0; Pro $20/mo; Builder $200/mo	Request-driven with app, CPU, and memory meters	Free includes 20 GB; Pro includes 200 GB then $0.50/GB	Deno Deploy Classic shut down July 20, 2026; use the current product
Firebase App Hosting	Managed full-stack web hosting on Google services	Requires the Blaze pay-as-you-go plan	Backends use Cloud Run behavior; builds and artifacts are separate services	10 GiB outgoing allowance, then cached and uncached delivery use different rates	The invoice spans App Hosting, Cloud Run, Build, Artifact Registry, logging, secrets, and data services
Firebase Hosting	Static hosting plus optional functions	Spark free tier; Blaze pay-as-you-go	Static delivery; dynamic code runs in separate functions or Cloud Run	10 GB storage and 360 MB/day transfer allowance, then storage and transfer charges	Daily transfer allowance and separate backend billing can surprise
AWS Amplify Hosting	Git-based frontend and SSR hosting	Usage-based; new AWS accounts may receive time-limited credits	Static and server-side rendering are metered separately	Storage, build minutes, transfer, SSR requests, and SSR duration are separate meters	WAF and backend services can add separate line items
Azure Static Web Apps	Static frontend plus integrated APIs	Free and Standard tiers; Standard price is region/currency dependent	Static delivery; integrated functions are request-driven	Allowance is subscription-wide; free sites can stop serving after quota exhaustion	Free resource, deployment, domain, and API limits are materially lower
GitHub Pages	Repository-backed static hosting	$0 with eligible GitHub repositories and plans	Static only	1 GB published site and a 100 GB/month soft bandwidth limit	Not intended as free hosting for an online business, ecommerce site, or SaaS
GitLab Pages	CI-built static hosting	Included according to GitLab plan and runner/CI allowances	Static only	Build minutes, artifacts, storage, and GitLab.com limits matter	The site can be free while CI runner and storage use are not
Surge	CLI-first static publishing	Free; Professional $30/mo	Static only	CDN delivery is bundled; no public granular transfer matrix on the pricing page	No general server-side runtime; advanced controls require Professional
Fastly Compute	Programmable edge compute	10M compute requests and 100M vCPU-ms free, then usage-based	Request-driven at the edge	Delivery bandwidth is priced separately by destination region after free allowance	Compute, CDN delivery, storage, TLS, and observability are distinct products
Wasmer Edge	WebAssembly and container edge platform	Hobby free; Pro $10/mo; higher plans available	Edge instances and volumes are metered by plan	Free and Pro include published bandwidth allowances, then paid transfer on Pro	The current pricing page contains conflicting headline and detailed compute allowances
Sevalla Static Site Hosting	Git-based static hosting	Free for up to 100 static sites under published fair-use limits	Static only	1 GB/site, 100 GB bandwidth, and 600 build minutes in the checked free offer	Fair use applies and dynamic applications need Sevalla Application Hosting
Stormkit	Frontend deployment cloud or self-hosted control plane	Cloud starts around $20/mo; self-hosted Free, Premium $20/seat, Ultimate $100/seat	Static, server files, and API files use different backends	Self-hosted transfer follows your infrastructure; cloud details require the live plan	Cloud and self-hosted economics are different; current cloud free trial was discontinued

General PaaS and managed application/container platforms (32)

Platform	Workload model	Public entry signal	Idle/scaling	Network model	Main catch
Railway	Metered container PaaS	Free trial then $1 allowance; Hobby $5 minimum; Pro $20 minimum	Services can be always-on; user-configured behavior determines idle cost	$0.05/GB public egress; CPU, RAM, volume, and object storage are separate	A database is another metered service; credits do not roll over
Render	Git-to-PaaS for web, workers, cron, static, and databases	Free evaluation resources; paid web service from $7/mo; workspace Pro $25/mo	Free web services sleep after 15 minutes; paid services remain available	Workspace bandwidth allowance, then $0.15/GB on current Hobby/Pro terms	Free Postgres expires after 30 days; disks and database storage are separately priced
Fly.io	Globally distributed micro-VM platform	Usage-based; shared 512 MB machine is roughly $3.32/mo if always running	Machines can autostop/autostart; reservations and attached resources persist	Regional egress from about $0.02/GB in North America and Europe	Volumes are local and bill while allocated; multi-region state requires engineering
Heroku	Classic buildpack/container PaaS	Eco $5 pooled hours; Basic $7; Standard-1X $25	Eco dynos sleep; paid production dynos are always-on	Transfer is not presented as a simple bundled quota; add-ons have separate bills	Ephemeral filesystem, add-on costs, and sustaining-engineering status
DigitalOcean App Platform	Managed app and static-site PaaS	Static free allowance; service from $5/mo for 512 MiB	Paid services are allocated continuously; jobs and functions differ	Plan transfer allowance pooled at team level; overage $0.02/GiB	Dedicated egress IP, managed databases, and some components add cost
Koyeb	Global serverless/container PaaS	Free 0.1 vCPU/512 MB; Nano about $2.68; Micro about $5.36	Free sleeps after one hour; scale-to-zero remains product/feature dependent	100 GB outbound allowance; published overage rate exists but billing status must be checked	Free services cannot use workers or volumes; preview volumes are local and non-redundant
Northflank	PaaS for services, jobs, databases, and pipelines	Sandbox free; PAYG from about $2.70/mo for 0.1 shared CPU/256 MB	Always-on and job patterns supported; billed per second	$0.06/GB egress, $0.02/GB cross-zone, disk $0.15/GB/mo	Its breadth is useful but more complex than a single-service hobby host
Back4app Containers	Fixed-price container hosting	Free 0.25 CPU/256 MB; shared 0.5 CPU/512 MB $5/mo	Fixed container allocation rather than a pure request meter	Free and $5 plans include 100 GB transfer	Do not infer zero-idle billing from serverless marketing language
Leapcell	Scale-to-zero functions and persistent services	Usage-based from about $0.60/M invocations and $0.18/GB-hour	Offers serverless scale-to-zero and persistent deployment modes	Small included quotas; egress can be $0.30/GB and large ingress payloads can be metered	Builds, logs, ingress, egress, and execution duration are separate meters
Zeabur	Developer PaaS with service templates	Free; Developer $5; Pro $19; Team $79 plus resource/server use	Depends on deployed service and region	Region and provider-specific resources affect traffic economics	The subscription is not the complete infrastructure bill
Replit Deployments	Browser IDE plus autoscale, reserved, scheduled, and static deployments	Starter free; Core $25 monthly or $20 annual; Pro $100 monthly or $95 annual	Autoscale and reserved modes have different economics	Core includes a published transfer allowance across deployments; usage consumes credits	Plan credits are not unlimited compute and editor subscriptions affect total cost
Sevalla Application Hosting	Managed application and database hosting	Applications from $5/mo; databases from $5/mo	Allocated runtime plans; background workers and cron supported	Provider advertises no separate app ingress/egress charge, subject to fair use	Fair-use language and separate database/object-storage resources still matter
Upsun	Git-driven composable PaaS	Resource-based; shared app CPU around EUR0.033/hour and app RAM around EUR0.013/GB-hour	Allocated environments and preview branches are billed by resources	Traffic and service pricing depend on plan and region	Resource composition is flexible but harder to compare with a single fixed container
Platform.sh	Enterprise application PaaS	Contract and resource-based pricing	Persistent application environments with preview workflows	Transfer and environment allowances are contract-specific	Usually outside hobby pricing; Upsun is the more accessible adjacent offer
Clever Cloud	European multi-runtime PaaS	Usage-based through a live calculator	Scalable application instances and managed add-ons	Use the calculator for current region and add-on terms	Dynamic pricing prevents a durable one-number comparison
Scalingo	European Heroku-style PaaS	30-day trial then container and add-on pricing	Allocated containers; autoscaling available by plan	Application egress is advertised at no additional charge; container bandwidth has limits	No egress fee does not mean unlimited per-container throughput
Sliplane	Managed Docker deployment on dedicated servers	Server from EUR9/mo, hourly billed; unlimited apps/containers per server	The server is always allocated even when an app is quiet	Underlying server provider transfer and fair-use rules apply	Blast radius, capacity planning, and noisy apps are shared across your server
Elestio	Managed open-source software and custom containers	Dedicated VM from about $11/mo; BYOVM management from $5 plus infrastructure	Always-on VM or BYOVM resources	Bandwidth depends on infrastructure/region; overage can vary by region	It is not a scale-to-zero bargain for one tiny endpoint
PikaPods	Managed catalog of open-source applications	Small pods can start around $1.80/mo	Pods are allocated; stopped pods still retain billable storage/minimums	Traffic policy is service-specific rather than a public cloud-style egress matrix	Not a general arbitrary-code PaaS
PythonAnywhere	Managed Python hosting	Beginner free; Developer $10/mo; larger plans available	Web workers and always-on tasks are plan-limited	Outbound access is restricted on free; no simple transfer bundle comparison	Python-only constraints and worker/task limits
alwaysdata	European managed multi-runtime hosting	Free personal plan; Plus from EUR5/mo annual or EUR6 monthly	Websites, databases, daemons, and scheduled tasks share the account resources	All-inclusive plan model rather than per-GB cloud billing	Free is personal and limited to an alwaysdata.net address; shared-resource limits matter
Cloud 66	BYOC deployment and operations layer	Free plan; paid management starts per managed server; cloud bill separate	Your servers stay allocated in your cloud account	Traffic follows the chosen cloud/VPS provider	Free/paid control-plane pricing is only one part of total cost
Bunny Magic Containers	Globally distributed container platform	$0.02/vCPU-hour, $0.005/GB RAM-hour, storage $0.10/GB-mo	At least one instance per selected region can remain active; dynamic scaling adds instances	$0.01/GB in Europe/North America, higher in other regions	Anycast IP, persistent storage, traffic, and multi-region minimums add up
Google App Engine	Managed application PaaS in Standard or Flexible environments	Usage-based with product-specific free quotas in Standard	Standard can scale toward zero; Flexible runs Compute Engine-based instances	Google Cloud network, storage, logs, and connected services are separate	Standard and Flexible are economically and operationally different products
Azure App Service	Managed web app and API hosting	Free/shared evaluation tiers and paid instance plans; region-dependent	Paid App Service plans allocate workers; serverless behavior requires other Azure products	Outbound transfer, private networking, databases, and monitoring can be separate	An App Service Plan can be shared by apps, making per-app comparisons misleading
AWS Elastic Beanstalk	AWS application orchestration over EC2 and related services	No Beanstalk surcharge; pay for EC2, load balancer, disk, storage, and transfer	Underlying instances and load balancers remain billable	AWS data transfer and load-balancer processing apply	No platform fee does not mean a cheap deployment; the generated AWS architecture is the bill
AWS Lightsail Containers	Fixed-price managed container nodes	Nano $7/mo 0.25 vCPU/512 MB; Micro $10; larger nodes to $160	Nodes are continuously allocated	500 GB transfer per service, then region-dependent overage starting around $0.09/GB	Traffic above 500 GB becomes expensive and it is less flexible than ECS
Appwrite Sites and Functions	Backend platform with web hosting and serverless functions	Free development tier and usage-based Cloud plans	Sites are built/deployed; functions are invocation-driven	Bandwidth, builds, executions, databases, storage, and users share product quotas	An all-in-one quota is convenient but increases platform coupling
Laravel Cloud	Managed Laravel and Symfony application platform	Starter $5/mo plus usage with $5 monthly credit; Growth $20/mo plus usage	Flex compute and supported databases can scale to zero; Laravel explicitly describes the platform as server-based, not serverless	App compute, databases, cache, storage, bandwidth, builds, and logs follow separate usage meters	The base plan is only part of the bill; wake behavior, resource class, and region still matter
Gigalixir	Elixir/Phoenix-focused buildpack PaaS	Free 0.5 GB prototype tier; Standard starts at $10/mo for one 0.2 GB replica	Free apps scale to zero after 30 days without a deploy; Standard replicas bill per second and do not sleep	Standard production bandwidth is included under fair use; dedicated ingress is a separate option	Free database is limited to 10,000 rows and 2 connections with no backups; static outbound IP is not standard
shinyapps.io	Managed R Shiny application hosting	Free 5 apps/25 active hours; Starter $13/mo for 25 apps/100 active hours	Usage is governed by active-hour allowances and plan resource behavior	No simple public per-GB egress matrix; app count, active hours, authentication, and domains drive the plan	Custom domains require the $349/mo Professional tier; it is R/Shiny-specific rather than general PaaS
Posit Connect Cloud	Managed R and Python data-app and document publishing	Free; Basic $19/mo; Enhanced $59/mo; Advanced from $249/mo for 5 seats	Applications consume monthly active-hour allowances; documents and app limits differ by plan	No simple public per-GB egress matrix; active hours, apps, seats, sharing, domains, and compute drive plan choice	The Free plan is public/GitHub-oriented; private sharing, custom domains, and team governance require higher plans

Serverless containers, functions, AI, and durable workflow runtimes (20)

Platform	Workload model	Public entry signal	Idle/scaling	Network model	Main catch
Google Cloud Run	Serverless containers	Request-based free grants; pay for vCPU, memory, requests, and related services	Can scale to zero; minimum instances create idle cost	Internet egress, load balancing, build, registry, logs, and VPC access can be separate	Concurrency and CPU-allocation settings can change both latency and price
Azure Container Apps	Serverless containers and jobs	Monthly free grant, then active/idle vCPU and memory plus requests	Can scale to zero for supported workloads; minimum replicas incur idle charges	Logging, registry, egress, private endpoints, and environment services are separate	Idle versus active billing and environment networking need careful configuration
Cloudflare Containers	Containers controlled through Workers	Available on Workers Paid, which starts at $5/account/mo; included compute allowance	Containers sleep and wake; active time is metered	Separate regional container egress after included 500 GB or 1 TB allowances	Workers has no egress fee, but Containers does; ephemeral disk and HTTP constraints matter
IBM Code Engine	Serverless apps, jobs, functions, and builds	Free grant then vCPU-second, GB-second, and request pricing	Applications can scale to zero; jobs pay while executing	IBM Cloud service and transfer charges can apply around the workload	Region availability and adjacent IBM service pricing should be checked
Scaleway Serverless Containers	European serverless containers	Usage-based active CPU and memory; use the current regional calculator	Scales to zero and does not charge inactive instances	Regional outbound transfer and connected storage/database services are separate	Pricing changed June 1, 2026; old comparison tables are stale
AWS ECS Express Mode	Simplified ECS deployment using AWS resources	No Express surcharge; pay for Fargate/EC2, ALB, logs, storage, and transfer	Default services are provisioned resources, not a tiny zero-idle function	ALB processing, public transfer, NAT, and cross-AZ can dominate	The default architecture can cost much more than one hobby container
AWS Lambda	Event-driven functions	Free monthly request and compute grants, then request and GB-second pricing	Scales to zero; provisioned concurrency costs while reserved	API Gateway, streaming, logs, NAT, storage, and egress are separate	Timeouts, cold starts, packaging, and adjacent-service costs shape the real architecture
Azure Functions	Event-driven functions	Consumption free grant then executions and GB-seconds; other plans available	Consumption can scale to zero; Premium and dedicated plans reserve capacity	Storage account, Application Insights, networking, and egress are separate	There are multiple hosting plans with materially different idle and scaling behavior
Google Cloud Run functions	Functions on the Cloud Run execution stack	Usage-based with free grants shared across relevant Google serverless use	Scales to zero; minimum instances and concurrency alter economics	Build, artifact, eventing, logging, and egress services add cost	Second-generation functions inherit Cloud Run concepts and connected-service billing
Zoho Catalyst AppSail and Functions	Serverless functions plus application runtime and BaaS	Monthly free allowances with PAYG; subscriptions from $25/mo plus $5 benefit	Functions are execution-based; AppSail is billed per instance-minute	Data store, file store, cache, mail, search, and other operations have individual meters	Free allowances are account-wide and the multi-service price model is detailed
Modal	Serverless Python and GPU compute	Starter $0 with $30 monthly compute credit; Team $250 with credit	Containers start for work and can keep warm by configuration	Compute, GPU, storage, volumes, and external services are separately relevant	Not a conventional full-stack PaaS; GPU and warm-capacity settings drive cost
Val Town	Hosted TypeScript functions, crons, APIs, and small apps	Free; Pro $25 monthly or $250/year; Business higher	Request/schedule-driven; runtime and run limits by plan	Run count, duration, email, logs, domains, and privacy limits matter more than bulk egress	It is intentionally constrained compared with a general container host
Hugging Face Spaces	Hosted ML demos and applications	CPU Basic free; upgraded CPU from $0.03/hour; GPUs from published hourly rates	Spaces can sleep; dedicated hardware bills while allocated according to settings	Model, dataset, storage, and inference products have separate limits	Not a general business web host; private and production needs can change the bill
Streamlit Community Cloud	Managed public Streamlit app hosting	Free Community Cloud	Apps can sleep and restart; resource limits are platform-controlled	No general egress price matrix because it is a hosted community product	Python/Streamlit-specific, public-oriented, and not a general production backend
Upstash Box	On-demand Linux boxes for agents and jobs	Free allowance; PAYG roughly $0.10-$0.40 per active CPU-hour; keep-alive from $8/mo	Active CPU is metered; keep-alive buys persistent availability	Storage and downstream services have separate pricing	A kept-alive box becomes a fixed monthly server-like expense
Pipedream	Serverless integrations and developer workflows	Free; paid workflow plans and Connect use credit-based pricing	Only workflow execution consumes compute credits; development tests are free	Credits scale with 30-second compute segments and memory; external API usage is separate	Not a general always-on web host; credit math and connected-account limits matter
Trigger.dev	Durable background tasks and AI jobs	Free tier; paid Cloud plan currently $50/mo with included credits	Tasks run on configured machines; no need to hold your web request open	Compute credits, concurrency, preview branches, dashboards, and seats can add cost	It complements an app host rather than replacing the frontend/API host
Inngest	Durable functions, workflows, queues, and events	Hobby free; Pro starts at $99/mo	Event-driven steps execute durably without an always-on worker fleet	Executions, concurrency, events, workers, span data, users, and retention are metered	It is an orchestration layer, not a database or general-purpose web origin
Fermyon Cloud	Serverless WebAssembly functions and microservices using Spin	Starter $0; Growth $19.38/mo; Enterprise custom	Request-driven WebAssembly execution with plan quotas rather than an always-on server	Starter includes 5 GB egress; Growth 50 GB; request, app, key-value, and SQLite quotas also apply	The Spin/Wasm runtime is intentionally narrower than an arbitrary Linux container
Laravel Vapor	Serverless Laravel deployment into the customer AWS account	Sandbox free; Unlimited $39/mo or $399/year, plus AWS charges	AWS Lambda scales by invocation; provisioned concurrency and related AWS resources can create a floor	API Gateway/CloudFront, Lambda, RDS, S3, logs, NAT, and AWS egress remain separate	Laravel-specific conventions plus a Vapor subscription and the full AWS bill

BYOC and self-hosted deployment platforms (19)

Platform/tool	Workload model	Platform price	Idle/scaling	Network model	Main catch
Porter	Managed BYOC PaaS on AWS/Azure/GCP	Platform fee roughly $6/GB RAM-mo and $13/vCPU-mo plus cloud bill	Underlying Kubernetes/cloud resources remain allocated	All cloud networking, load balancers, NAT, storage, and egress are paid to the cloud	Kubernetes and provider minimums make it poor economics for one tiny hobby app
Qovery	BYOC Kubernetes platform	Team and Business are usage-based; Enterprise custom	Apps run on clusters in the customer cloud account	Cloud provider transfer and infrastructure costs are separate	Current pricing is no longer a simple low-cost hobby tier
Encore Cloud	Backend framework plus managed/BYOC cloud automation	Pro $49/member/mo plus environment and resource fees, then cloud bill	Generated cloud resources follow their provider billing	Cloud transfer, database, queue, and observability costs remain	Seat, environment, resource, and cloud charges stack
SST	Open-source framework plus optional Console for own-cloud deployments	Framework free; Console free to 350 active resources then per-resource	AWS or other provider resources follow their native billing	Native cloud egress, NAT, logs, functions, and databases remain your bill	Portability is improved, but cloud complexity and cost do not disappear
Flightcontrol	Developer control plane for applications in the customer AWS account	Starter $97/mo for 5 services; Business $397/mo; AWS bill separate	ECS/Fargate or ECS/EC2 resources remain allocated according to configuration	ALB, NAT, transfer, storage, database, and logs are AWS charges	A tiny web service can require load-balancer and networking costs; the site identifies Ravion as successor
Coolify	Open-source self-hosted PaaS plus hosted control plane	Self-host free; Cloud $5/mo includes 2 connected servers, then $3/server	Your VPS/server stays on; applications share its capacity	Transfer follows the connected server provider	You own patching, backups, capacity, firewalling, and incident response
Dokploy	Open-source Docker deployment platform plus hosted control plane	Self-host free; cloud Hobby about $4.50/server; Startup $15 with 3 servers	Connected servers are continuously billed	Underlying VPS/cloud traffic and port limits apply	Control-plane convenience does not make application data automatically highly available
Easypanel	Self-hosted server panel for apps and databases	Free up to 3 projects; paid from about $10.90/mo annual-effective	Requires an always-on Linux server, recommended at 2 GB RAM or more	Server provider transfer applies	Panel subscription and VPS are separate; free project cap is small
CapRover	Open-source self-hosted PaaS	Free software; pay for server, backups, and operations	Always-on server and Docker services	Underlying server transfer and firewall rules apply	Persistent apps are tied to nodes unless you design storage and HA yourself
Dokku	Open-source Heroku-like PaaS for one or more servers	Free open source; optional Dokku Pro is a separate lifetime license	Always-on host; app processes consume assigned server resources	Server provider transfer applies	You operate the host, plugins, data, backups, and scaling
Kamal	Open-source Docker deployment tool	Free software; pay for servers, registry, storage, and operations	Deploys long-running containers to your servers	Server and registry traffic policies apply	It automates deployment, not full managed hosting, databases, backups, or autoscaling
Kubero	Open-source Kubernetes-native PaaS	No software licensing fee for self-hosting	Runs on a Kubernetes cluster whose nodes remain billable	Cluster load balancer, storage, and cloud egress apply	Kubernetes minimums and operational surface are excessive for many solo projects
OpenFaaS	Self-hosted functions and jobs on Kubernetes or container infrastructure	Community and commercial editions; infrastructure billed separately	Functions can scale according to configuration; cluster remains	Cluster, gateway, storage, and cloud networking determine cost	It is infrastructure software, not a zero-operations free cloud
Piku	Minimal Git-push PaaS for personal servers	Free open source; pay for one small server	Always-on server with app processes	Server provider transfer applies	Deliberately minimal feature set and small community compared with larger panels
Laravel Forge	Server management and Git deployment for owned VPS/cloud servers	Hobby $12/mo; Growth $19/mo; Business $39/mo, plus server/provider costs	Provisioned servers and databases stay allocated; scaling is primarily server-based	Bandwidth, addresses, backups, and overage follow Laravel VPS or the connected provider	Forge automates operations but does not turn the server into managed or scale-to-zero hosting
Ploi	Hosted server management and deployment control plane	Free; Basic EUR8/mo; Pro EUR13/mo; Unlimited EUR30/mo; annual billing saves 10%	Connected VPS/cloud servers remain continuously billable	Transfer, public IP, disk, and backup costs follow the chosen infrastructure and backup target	The panel fee is separate from every server; annual billing changes effective monthly cost
RunCloud	Managed PHP server control panel for owned cloud servers	Essentials $9/mo; Professional $19; Business $49; Enterprise $399	Connected servers remain always allocated	Cloud/VPS bandwidth, storage, backups, and addresses remain provider charges	It manages servers rather than abstracting them; application portability and HA remain the owner's job
CloudPanel	Free self-hosted server control panel	Free software; pay for server, backups, storage, and administration	The underlying server and its services remain on	Transfer and network limits follow AWS, DigitalOcean, Hetzner, Azure, GCP, Vultr, or another host	It is a server panel, not a Git-to-PaaS with automatic multi-node scaling and managed state
Cloudron	Self-hosted packaged-application platform with automatic app updates	Free for 2 apps; Pro starts around EUR15/mo annual-effective; monthly billing is higher	The server and installed applications stay allocated	VPS bandwidth, backups, mail delivery, and external storage follow the owner's infrastructure	It is an app catalog/appliance platform, not a general arbitrary-code deployment service

What free really means

The word "free" covers at least six different offers:

1. Personal/non-commercial: useful for a portfolio, invalid for a paid product.

2. Static delivery: genuinely cheap because there is no server process.

3. Sleeping evaluation instance: useful for demos, unsuitable for predictable latency.

4. Monthly usage grant: valid until requests, CPU, memory, traffic, builds, or storage consume it.

5. Trial credit: expires after days or months and is not a permanent tier.

6. Free software: the control plane costs $0, but the server and operations do not.

Free offer	Commercial-use reality	What happens at/after idle or quota	Notable allowance
Vercel Hobby	No - personal, non-commercial	Hard plan limits; cannot buy extra usage	100 GB transfer in checked matrix; 1M edge requests
Netlify Free	Check project/account terms	300 monthly credits; account can pause when exhausted	Bandwidth, compute, requests, and deploys share credits
Cloudflare Workers Free	Generally usable for projects under service terms	100,000 requests/day and 10 ms CPU/invocation	No separate Workers egress; static assets free
Deno Deploy Free	Positioned for personal/smaller projects	Monthly quotas, then upgrade	1M requests, 20 GB egress, 15 CPU hours
GitHub Pages	Not for online business/ecommerce/SaaS hosting	Soft usage limits and repository rules	1 GB site and 100 GB/month soft bandwidth
Surge Free	Static projects under terms	No public project/deploy cap in current docs	Custom domains and managed SSL
Sevalla Static	Yes under fair use	Fair-use limits	100 sites, 100 GB bandwidth, 600 build minutes
Railway Free after trial	Very limited	$1 monthly allowance after 30-day $5 trial	1 project, 3 services, no custom domain after trial
Render Free	Evaluation-oriented	Web sleeps after 15 min; free Postgres expires in 30 days	512 MB/0.1 CPU free web resource
Koyeb Free	Small workloads	Sleeps after one hour	0.1 vCPU/512 MB/2 GB; no worker or volume
Back4app Free Container	Small apps under terms	Fixed free resource	0.25 CPU/256 MB/100 GB transfer
Northflank Sandbox	Development/sandbox	Always-on within small resource limits	2 services, 1 database, 2 cron jobs
PythonAnywhere Beginner	Learning/small use	Restricted outbound and one worker	One pythonanywhere.com web app
alwaysdata Free	No - personal use	Shared 256 MB/quarter CPU/1 GB disk	No custom domain on Free
Hugging Face CPU Basic	Public demo-oriented	Can sleep; controlled resources	2 vCPU/16 GB published CPU Basic
Streamlit Community Cloud	Public community app use	Sleeps/restarts and platform limits	Free public Streamlit apps
Fermyon Cloud Starter	Small WebAssembly applications under service terms	Monthly quotas, then upgrade	5 apps, 100,000 requests, and 5 GB egress
Gigalixir Free	Prototype and development use	Can sleep/scale to zero after prolonged inactivity	Free Elixir app and small database with strict limits
shinyapps.io Free	Public Shiny applications under plan terms	25 active hours shared across 5 apps	5 applications and community support
Posit Connect Cloud Free	Public R/Python apps and documents under plan terms	20 monthly active hours; public-repository workflow	4 GB memory, 1 CPU, and up to 5 applications
Laravel Vapor Sandbox	Evaluation and small experiments; AWS account still required	AWS usage remains separately billable	Vapor control plane is free on Sandbox

The correct question is not "Does it have a free tier?" It is:

Can this exact commercial or personal workload remain within the free tier without sleep, expiry, account suspension, prohibited use, or an external paid database?

For a public documentation site, the answer may be yes. For a customer-facing SaaS with Postgres, background jobs, email, storage, and backups, the answer is usually no.

Egress and bandwidth compared

App-platform pricing pages often emphasize CPU and requests because network transfer is harder to summarize. Yet a media-heavy app, file proxy, API aggregator, or AI output service can spend more on egress than compute.

Platform	Included/charging model	Public overage signal	Important catch
Cloudflare Workers	No separate egress meter	None for Workers traffic	Storage products and Containers have their own pricing
Cloudflare Containers	1 TB NA/Europe or 500 GB in other listed bands	About $0.025-$0.05/GB by region	This is different from Workers pricing
Vercel Pro	1 TB in checked plan matrix	$0.15/GB	Seat fee and function/request meters also apply
Netlify Pro	Credits, not a dedicated GB bundle	20 credits/GB; recharge packs	Deploys, requests, and compute use same credits
Deno Deploy Pro	200 GB	$0.50/GB	High transfer can dominate quickly
Railway	No broad bundled public egress on usage plans	$0.05/GB	Object storage egress policy differs
Fly.io	No general large bundle for new PAYG accounts	About $0.02-$0.12/GB by region	Inter-region and product traffic distinctions matter
DigitalOcean App Platform	Plan allowance, pooled by team	$0.02/GiB	Dashboard visibility of cumulative usage has limitations
Back4app $5 container	100 GB	Check current plan terms	Fixed compute resource remains the main plan constraint
Bunny Magic Containers	No broad free bundle stated	$0.01/GB NA/EU; higher elsewhere	One active instance per selected region plus anycast/storage
AWS Lightsail Containers	500 GB/service	Starts around $0.09/GB by region	Both directions count toward allowance, outbound overage is billed
AWS Amplify Hosting	15 GB transfer under published allowance	$0.15/GB	Build, storage, SSR, WAF, and backend separate
Firebase Hosting	360 MB/day	$0.15/GB	Daily allowance is less flexible than a monthly pool
Fastly delivery + Compute	100 GB delivery and 10M compute requests free	Bandwidth varies by destination region	Compute and delivery are distinct meters
Google Cloud Run	Serverless free grant does not erase all network charges	Google Cloud regional internet egress rates	Load balancer, VPC, logs, build, and registry can add cost

Four network questions to ask

1. Is the allowance measured in decimal GB or binary GiB?
2. Is it inbound, outbound, or both directions?
3. Is it pooled across projects, teams, services, or regions?
4. What happens after the allowance: overage, throttling, pause, or fair-use review?

Why the lowest per-GB rate is not automatically best

A platform with $0.01/GB egress can still be more expensive if it requires one active instance in several regions. A platform with $0.15/GB can be cheaper if the plan includes 1 TB and the project sends only 200 GB. Compare the whole workload.

Major platform analysis

Vercel: best commercial Next.js experience, not the cheapest generic backend

Verified facts: Vercel Hobby is $0 and restricted to personal, non-commercial use. Pro is $20 per developer per month and includes a $20 usage credit. The checked matrix lists 1 TB of transfer on Pro and $0.15/GB overage, plus separate request, function CPU, memory, invocation, build, and observability limits.

Editorial inference: Vercel Pro is the right reference choice when the team uses Next.js features deeply and values preview URLs, framework-aware caching, image handling, integrated analytics, and minimal operational work. The product is less compelling as a generic always-on worker or heavy data-transfer origin.

The decisive question is not whether another platform can run next build. It is whether the application uses Vercel-specific or Vercel-optimized behavior: ISR, middleware, fluid compute, image optimization, cache revalidation, edge functions, and branch previews.

Main traps:

• Every developer seat establishes a fixed floor.
• The $20 usage credit is not unlimited runtime.
• A function-heavy app can consume CPU, memory, invocation, and transfer meters simultaneously.
• Hobby cannot simply buy overage and remain a commercial production plan.

Netlify: the closest broad frontend workflow, with a credit abstraction

Netlify remains a strong choice for framework-neutral frontend teams. Its current pricing converts production deploys, bandwidth, compute, and requests into credits. That simplifies the invoice to one pool but makes resource planning less intuitive.

At the checked rates, a production deployment costs 15 credits, bandwidth 20 credits/GB, compute 10 credits/GB-hour, and requests 2 credits per 10,000. Free includes 300 credits, Personal 1,000, and Pro 3,000. Auto-recharge is optional rather than automatic by default.

Editorial inference: Netlify is attractive when frontend workflow, forms, previews, functions, and team collaboration are the product. It is less attractive when the reader wants a transparent CPU/RAM server or pushes large files.

Cloudflare Workers and Static Assets: strongest low-cost edge/static default

Cloudflare Workers Paid starts at $5 per account and includes a large request and CPU allowance. Workers does not add separate egress or throughput charges, and static asset requests are free. That creates a rare combination: commercial use, edge execution, and low network-price risk.

The tradeoff is runtime shape. Workers is not an arbitrary always-on Linux process. CPU time, subrequests, memory, runtime APIs, Durable Objects, storage operations, and service-specific limits matter.

Cloudflare Containers expands the model toward ordinary containers, but it must be priced separately. The current container offer includes compute allowances with Workers Paid and then meters active compute, disk, and regional egress. In North America and Europe, the checked allowance is 1 TB before about $0.025/GB; other bands use 500 GB and higher rates.

Editorial inference: Use Workers for edge APIs, middleware, authentication, caching, lightweight SaaS backends, and static sites. Use Containers only when the container runtime solves a real compatibility problem and the separate economics remain favorable.

Deno Deploy: credible web-standard serverless, with a recent product boundary

The current Deno Deploy Free plan publishes 1 million requests, 20 GB egress, 15 CPU hours, 350 GB-hours of memory, 20 apps, and a 1 GiB volume. Pro is $20 with larger allowances, then $2 per million requests, $0.50/GB egress, and active CPU/memory overages.

Deno Deploy Classic shut down on July 20, 2026. Old tutorials that point to the Classic dashboard or Classic limits are obsolete.

Editorial inference: Deno Deploy is a strong option for TypeScript applications written to web standards and Deno tooling. The $0.50/GB Pro overage makes it a poor choice for large origin transfer unless caching or architecture reduces egress.

Railway: best approachable full-stack usage-metered PaaS

Railway's strength is that web services, workers, cron, databases, volumes, object storage, variables, networking, and logs live in one project model. Hobby has a $5 monthly minimum that includes $5 of usage; Pro has a $20 minimum with $20 included.

Current public resource rates include approximately $0.00000772 per vCPU-second, $0.00000386 per GB-second of RAM, and $0.05/GB public egress.

At those rates, a continuously allocated 0.5 vCPU and 0.5 GB service is about $15.22/month before egress and storage. A continuously allocated 1 vCPU and 1 GB service is about $30.43/month. The subscription minimum is not added again when usage already exceeds it.

Editorial inference: Railway is excellent when the project is naturally a graph of ordinary services and the owner wants to see usage by service. It is not automatically cheap for idle databases, workers, and duplicated preview environments.

Render: useful free evaluation, clear paid PaaS

Render's free web service has 512 MB RAM and 0.1 CPU, sleeps after 15 minutes of inactivity, and can take roughly a minute to wake. Free PostgreSQL expires after 30 days. Paid web service pricing currently starts at $7/month for 512 MB, with larger fixed sizes.

Workspace and network pricing changed in 2026. The current public plan matrix shows Hobby $0, Pro $25, Scale $499, and bandwidth allowances with $0.15/GB overage on lower workspace plans.

Editorial inference: Render Free is a good product demonstration, not a production promise. Render paid services suit teams that want Heroku-like ergonomics, private services, background workers, cron, disks, and managed databases without the Railway-style raw resource meter.

Fly.io: best control and placement among small-team platforms

Fly.io runs Firecracker-based Machines in many regions. Shared machine examples remain inexpensive: approximately $3.32/month for a continuously running 512 MB shared machine and $5.92 for 1 GB, before storage and traffic.

Machines can autostop and autostart, but volumes bill while allocated and are local to a region/host placement. Egress starts around $0.02/GB in North America and Europe, $0.04 in several other regions, and higher in Africa/India.

Editorial inference: Fly is compelling for latency-sensitive global applications, custom networking, WebSockets, and ordinary containers. It demands more architectural understanding than a single-region Git-to-PaaS. Stateless services are easy; globally consistent state is not.

Heroku: mature and supported, but now a roadmap decision

Heroku's Eco plan costs $5 for a shared pool of 1,000 dyno hours and sleeps. Basic is $7 for 512 MB. Standard-1X is $25, and databases, Redis, monitoring, and other add-ons are separate.

Heroku announced a sustaining-engineering model in February 2026: security, stability, reliability, and support continue, but the product is no longer positioned around aggressive feature growth.

Editorial inference: Existing stable workloads do not need a panic migration. New projects should compare the value of mature workflows and add-ons against a more actively expanding roadmap elsewhere.

DigitalOcean App Platform: best predictable small paid service in a familiar cloud

The smallest current paid application component is $5/month for 1 shared vCPU, 512 MiB RAM, and a transfer allowance. The next fixed small plans add memory and traffic. Static sites have a limited free allowance. Transfer overage is $0.02/GiB and plan allowances pool at team level.

Editorial inference: DigitalOcean App Platform is one of the easiest recommendations for a small always-on API when $5 fixed is preferable to per-second resource math. Managed databases, dedicated egress IP, and additional components must be added to the comparison.

Koyeb: attractive low-use global containers, with persistence caveats

Koyeb's Free service is 0.1 vCPU, 512 MB RAM, and 2 GB storage in selected regions. It sleeps after one hour and cannot be a worker or attach a volume. Standard Nano and Micro are approximately $2.68 and $5.36 per month.

The platform publishes 100 GB outbound included and a $0.04/GB overage rate, while a documentation note checked in May 2026 said the overage was not yet charged. That is an official-source ambiguity: confirm the live invoice rules.

Preview volumes are local, single-replica, non-redundant, and limited to selected regions. They are not a managed HA database substitute.

Northflank: strongest small-team service graph after Railway

Northflank combines services, jobs, cron, databases, pipelines, previews, secrets, and observability. Sandbox includes a small always-on allocation. PAYG starts around $2.70/month for 0.1 shared CPU and 256 MB; egress is $0.06/GB, cross-zone $0.02/GB, and disk $0.15/GB-month.

Editorial inference: Northflank is a strong fit when the application has several service types and the team wants one platform without immediately adopting Kubernetes. It is more to learn than a one-button host.

Back4app Containers: unusually clear fixed small plans

Back4app's free container publishes 0.25 shared CPU, 256 MB RAM, and 100 GB transfer. The $5 shared plan provides 0.5 CPU, 512 MB, and 100 GB. Larger fixed plans increase CPU, RAM, and transfer.

Editorial inference: It is a useful alternative for a small Dockerized API where predictable cash cost and included transfer matter. Treat it as fixed container hosting, not guaranteed zero-idle serverless.

Leapcell: flexible, but every meter matters

Leapcell supports scale-to-zero serverless deployments and persistent services. Public pricing begins around $0.60 per million invocations and $0.18 per GB-hour, but build minutes, log ingestion, egress, and even sufficiently large ingress payloads can be billed.

Editorial inference: It is interesting for polyglot hobby APIs and global deployment, but readers should estimate every meter instead of comparing only invocation price.

Replit Deployments: best integrated editor-to-launch workflow

Replit combines the development environment with autoscale, reserved, scheduled, and static deployments. Core is $25 monthly or $20/month annual-effective with $25 deployment credits; Pro is $100 monthly or $95 annual-effective with $100 credits.

Editorial inference: Replit wins when the browser workspace, collaboration, AI coding, and deployment are one workflow. It is not automatically the lowest infrastructure price, and credits must be modeled.

Bunny Magic Containers: important new global container alternative

Bunny publishes simple resource rates: $0.02 per CPU core-hour, $0.005 per GB RAM-hour, $0.10 per GB-month persistent storage, $2/month anycast IPv4, and traffic from $0.01/GB in Europe/North America.

One continuously active 1 vCPU/1 GB instance is approximately $18.25/month before traffic, IP, and storage. Multi-region deployment can multiply that floor because at least one instance per selected region is active.

Editorial inference: Magic Containers is compelling when global placement and low traffic rates matter. It is less compelling for a single tiny idle app that another platform can scale fully to zero.

Firebase App Hosting and Amplify: integrated clouds, integrated bills

Firebase App Hosting and AWS Amplify reduce framework deployment work but expose the economics of their parent clouds.

Firebase App Hosting requires Blaze and uses Cloud Run, Cloud Build, Artifact Registry, logging, secrets, and Firebase data services. Amplify separately meters builds, storage, transfer, SSR requests, and SSR duration; WAF and backend resources are additional.

Editorial inference: Choose them when the surrounding cloud ecosystem is an advantage. Do not choose solely because the frontend deploy button looks like a fixed-price host.

Laravel Cloud, Forge, and Vapor: one ecosystem, three different operating models

These products share Laravel branding, but they should not be treated as interchangeable plans.

Verified facts: Laravel Cloud Starter is $5/month plus usage and includes $5 in monthly usage credits; Growth is $20/month plus usage. Cloud supports scale-to-zero for eligible Flex compute and explicitly describes itself as server-based rather than serverless, with applications running on dedicated AWS EC2 infrastructure. A spending limit can pause compute when the configured threshold is reached.

Laravel Forge starts at $12/month for Hobby, $19/month for Growth, and $39/month for Business. Forge is a server-management control plane: the customer separately pays for and owns the server at a supported cloud or VPS provider.

Laravel Vapor has a free Sandbox and a paid production plan at $39/month or $399/year, excluding AWS charges. Vapor deploys Laravel applications into the customer's AWS account using Lambda and adjacent AWS services.

Editorial inference:

• Choose Laravel Cloud when the fastest first-party managed Laravel launch and scale-to-zero behavior are worth usage billing.
• Choose Forge when a conventional server, predictable VPS economics, persistent processes, and infrastructure ownership matter.
• Choose Vapor when Lambda's event-driven scaling, AWS integration, and serverless operational model fit the application.

The cheapest option can change with traffic shape. A quiet app may benefit from Cloud scale-to-zero or Vapor's request model; a continuously busy queue, WebSocket service, or memory-heavy application may be cheaper and simpler on a Forge-managed server.

Framework-specialist platforms are often better than a generic PaaS

Gigalixir is purpose-built around Elixir and Phoenix while also supporting other runtimes. Its free tier provides one 0.5 GB prototype replica and can sleep after 30 days without a deploy; current Standard pricing starts at $10/month for one 0.2 GB replica. The managed Postgres offer has separate size, connection, backup, and availability considerations.

shinyapps.io specializes in R Shiny. The free tier publishes up to five apps with 25 active hours; paid tiers increase active hours, application count, worker capacity, authentication, and custom-domain support. Posit now recommends Posit Connect Cloud for new projects: it supports Shiny, Streamlit, Dash, Bokeh, Quarto, R Markdown, and Jupyter, with Free, $19 Basic, $59 Enhanced, and a $249 team-oriented Advanced entry tier. shinyapps.io remains relevant for the established push-button Shiny workflow; Connect Cloud is the broader R/Python publishing platform.

Fermyon Cloud targets WebAssembly applications built around Spin. Starter is free with five apps, 100,000 requests, and 5 GB egress; Growth is $19.38/month with 100 apps, 1 million requests, and 50 GB egress. It is compelling for tiny, fast-starting Wasm services, but it is not a drop-in home for arbitrary long-running Linux processes.

Editorial inference: Specialist platforms can eliminate buildpacks, runtime tuning, and operational glue. Their cost is a narrower execution contract and potentially higher migration effort. Choose them when the framework-specific workflow is a primary advantage, not merely because the entry tier is cheap.

Serverless containers and functions

Google Cloud Run is the reference portable serverless container

Cloud Run's request-based free grant includes 180,000 vCPU-seconds, 360,000 GiB-seconds, and 2 million requests per month in eligible use. Instance-based billing has a different free grant. A service can scale to zero, while minimum instances reserve capacity and create idle cost.

It is the best comparison reference because the application contract is an ordinary container. That improves portability relative to a provider-specific edge runtime. The surrounding architecture remains cloud-specific: build, registry, logs, load balancing, secrets, VPC, database, and egress.

Azure Container Apps is the Azure equivalent with jobs

Azure Container Apps provides a monthly free grant and bills active/idle vCPU and memory plus requests. It supports HTTP apps, workers, jobs, revisions, environments, and KEDA-style scaling.

It is a strong choice for Azure-centric teams, especially when Container Apps jobs replace a continuously running worker. The main trap is assuming all replicas are active-only: minimum replicas, environment networking, logs, and adjacent services can establish a floor.

IBM Code Engine and Scaleway are credible alternatives

IBM Code Engine unifies applications, jobs, functions, and builds and publishes a free grant. Scaleway Serverless Containers offers European scale-to-zero billing for active compute. They deserve comparison when region, data residency, or ecosystem fit is better than AWS/Azure/Google.

AWS Lambda remains excellent for events, not universal hosting

Lambda is ideal for event handlers, queues, schedules, webhooks, and short APIs. It becomes awkward when the app needs long requests, native process control, large files, stateful connections, or stable warm capacity.

The Lambda function may be nearly free while API Gateway, CloudWatch logs, NAT, S3, DynamoDB/RDS, streaming responses, and data transfer form the bill.

AWS ECS Express Mode is not the new free App Runner

AWS App Runner stopped accepting new customers on April 30, 2026. AWS points new users toward ECS Express Mode. Express Mode has no separate surcharge, but it creates and uses ordinary AWS resources such as Fargate tasks, an Application Load Balancer, logs, and networking.

That is a simplification of ECS, not a tiny scale-to-zero hobby PaaS. A small task can cost less than its ALB/NAT architecture.

Modal, Val Town, and Upstash Box solve different problems

• Modal is for Python, AI inference, batch work, GPU use, and containerized functions.
• Val Town is for tiny TypeScript APIs, cron, automations, and internal tools.
• Upstash Box is for intermittent Linux execution and agent sandboxes, with optional keep-alive.

Comparing them by "RAM per dollar" misses why they exist.

Trigger.dev, Inngest, and Pipedream are complements

A web host should respond quickly; durable work should survive retries, deploys, timeouts, and process death. Trigger.dev and Inngest move long-running work into a durable execution layer. Pipedream combines serverless code with thousands of integrations.

The architecture becomes:

frontend/API host + durable workflow service + database + object storage + email/payment services

This can be more reliable than one monolith but introduces multiple bills and failure domains.

Self-hosted and bring-your-own-cloud alternatives

Coolify: best general self-hosted default

Coolify supports Git repositories, Docker images, databases, services, domains, TLS, backups, and multiple servers. The software is free to self-host. Coolify Cloud is a managed control plane at $5/month including two connected servers, then $3 per additional server.

Editorial inference: Coolify is the best default when a technically capable solo founder wants a broad PaaS on a VPS. It has more features and a larger mindshare than many one-server alternatives.

It does not remove these responsibilities:

• Operating-system and Docker updates
• Database backup and restore tests
• Off-site storage and secret handling
• Monitoring, alerts, and capacity planning
• Firewall, SSH, abuse, and incident response
• High availability and disaster recovery

Forge, Ploi, RunCloud, and CloudPanel: server control panels, not hosted compute

These tools sit between raw SSH administration and a full hosted PaaS.

• Laravel Forge starts at $12/month and is optimized for Laravel/PHP while supporting broader server workflows. The server bill is separate.
• Ploi offers Free, Basic at EUR8/month, Pro at EUR13/month, and Unlimited at EUR30/month; annual prepayment saves 10%. The tiers cover 1, 5, 10, and unlimited servers respectively, while server fees remain separate.
• RunCloud publishes Essentials at $9/month, Professional at $19, Business at $49, and Enterprise at $399. It manages PHP-oriented web stacks on customer servers.
• CloudPanel is free software for PHP, Node.js, Python, static sites, and reverse proxies. The user supplies the server and owns the operational burden.

Verified boundary: A control panel can automate TLS, virtual hosts, deployments, users, processes, and some backups. It does not automatically provide multi-zone availability, managed database recovery, abuse handling, capacity guarantees, or a second copy of the server.

Editorial inference: Forge is the cleanest Laravel-server choice; RunCloud and Ploi are stronger general PHP panel candidates; CloudPanel is attractive when the subscription must be $0 and the operator is comfortable owning the whole host.

Cloudron: an app catalog and appliance-like server layer

Cloudron provides a curated application catalog, automatic application updates, domains, mail integration, backups, and server management on infrastructure the customer supplies. The free edition supports two apps; paid plans start from approximately EUR15/month when billed on the lower annual-effective schedule, while the underlying VPS remains separate.

It is excellent for self-hosting packaged applications such as collaboration, file, and publishing tools. It is less suitable than Coolify, Dokploy, or a generic container PaaS for arbitrary microservices and custom deployment topologies.

Dokploy: best for Docker Compose and multi-server simplicity

Dokploy is open source and particularly comfortable for Docker Compose, databases, and multiple servers. Its hosted control plane has a low per-server entry price.

Editorial inference: Choose Dokploy when Compose-first workflows and a clean UI matter. Choose Coolify when its broader integrated feature set better matches the stack. Both inherit the underlying server's transfer, disk, CPU, and failure domain.

Easypanel and CapRover: good one-server panels

Easypanel offers a polished UI and a free three-project tier, then paid subscriptions. CapRover is free and mature, with Git/Docker deployment and one-click apps.

They are strong for one server. They require deliberate planning before calling a stateful service highly available.

Dokku and Kamal: fewer abstractions, more transparency

Dokku recreates a Heroku-like Git/buildpack workflow on a server. Kamal deploys Docker images over SSH, installs Docker when needed, and uses a proxy for gapless deploys and TLS.

Editorial inference: Dokku is better for a compact PaaS experience. Kamal is better for teams that want deployment automation without installing a large control plane.

Kubero and OpenFaaS: only when Kubernetes is already justified

Kubero provides a Heroku-like PaaS on Kubernetes. OpenFaaS provides functions and jobs on owned container infrastructure. Both are capable; neither makes Kubernetes free or simple.

A one-node cluster is not meaningfully highly available. Managed load balancers, persistent volumes, backups, upgrades, ingress, certificates, and observability remain.

BYOC: ownership with a double invoice

Porter, Qovery, Flightcontrol, Cloud 66, Encore, and SST preserve customer cloud ownership to different degrees. The advantages are real:

• Cloud credits can pay infrastructure.
• Workloads and data remain in the customer account.
• Native cloud services and compliance controls are available.
• Migration can be easier than extracting from a black-box runtime.

The disadvantage is equally real: the platform fee is added to the cloud invoice. Small workloads can be dominated by cluster nodes, load balancers, NAT, private networking, logs, and minimum database sizes.

For a solo project, BYOC is usually an architecture decision, not a cost-saving shortcut.

Backend and database companions

Many "Vercel stack" or "serverless stack" discussions compare a frontend host to a full PaaS while quietly assuming an external backend. The following services are important, but they do not all replace the main application host.

Backend companion	What it provides	Entry signal	Main trap
Supabase	Postgres, auth, storage, realtime, edge functions	Free; Pro $25/mo plus project compute beyond included credit	A paid project has ongoing compute; storage, egress, MAU, and backups have quotas
Neon	Serverless Postgres with branching and scale-to-zero	Free and usage-based paid plans	Compute units, storage, branches, history, and transfer can all matter
Turso	Distributed SQLite/libSQL database	Free; Developer about $4.99; Scaler about $24.92	Reads, writes, database count, storage, and locations are separate constraints
Upstash Redis/QStash/Workflow	Serverless Redis, messaging, schedules, and workflows	Free allowances then per-command/message/storage pricing	Retries can count as deliveries; command-heavy designs can cost more than storage
Convex	Reactive backend, database, functions, and realtime	Free development tier and paid usage plans	Convenient coupling can increase migration cost
Appwrite Cloud	Auth, database, storage, functions, messaging, and sites	Free and paid Cloud plans	Many features share plan quotas and one operational boundary
Firebase	Auth, Firestore/RTDB, storage, functions, hosting, messaging	Spark free and Blaze PAYG	Individual service meters make total cost workload-specific
Nhost	Postgres/Hasura, auth, storage, functions	Free and paid workspace/project plans	Resource and project limits differ from a generic database bill
MongoDB Atlas	Managed document database and adjacent data services	Free shared cluster and paid dedicated/serverless options	Backups, transfer, search, and dedicated sizing can dominate
Cloudflare D1/R2/KV/Durable Objects	Edge-adjacent SQL, object, key-value, and state	Product-specific free grants and usage meters	Workers egress policy does not imply every storage operation is free

The split-stack advantage

A split stack can choose the best component for each job: Cloudflare for edge delivery, Neon for Postgres, R2 for objects, Trigger.dev for long jobs, and a transactional email provider.

The split-stack cost

The application now has several identity systems, region choices, service limits, invoices, status pages, SDKs, and migration paths. Cross-provider traffic and latency can appear between the frontend, database, storage, and worker.

The correct comparison is between complete architectures, not logos.

Lifecycle warnings

A 2026 comparison that repeats an old list without checking current availability is dangerous.

Product	Current status	What the reader should do
AWS App Runner	No new customers since April 30, 2026	Existing users remain supported, but new projects should evaluate ECS Express Mode, Cloud Run, or another active PaaS.
Deno Deploy Classic	Shut down July 20, 2026	Use current Deno Deploy; do not rely on Classic-era limits or dashboard instructions.
Shuttle	Ceased operations; Pro projects stopped January 16, 2026	Treat old Rust-hosting comparisons as obsolete; verify Neptune separately if considering it.
Glitch project hosting	Ended July 8, 2025	Glitch is no longer an app-hosting recommendation.
Heroku	Active and supported, but moved to sustaining engineering in 2026	It remains viable for stable workloads, but roadmap-sensitive buyers should compare active-growth alternatives.
Flightcontrol / Ravion	Flightcontrol remains online; its site identifies Ravion as successor	Confirm migration, roadmap, and pricing directly before a new long-lived commitment.

Lifecycle risk does not mean every older platform must be abandoned. It means the exit path, data export, container portability, infrastructure ownership, and migration labor belong in the buying decision.

Cost scenarios

These scenarios are illustrative, before tax, and exclude database, backups, observability, support, and discounts unless stated. They compare workload shape, not benchmark performance.

Scenario 1: static commercial marketing site, 20 GB/month

Best candidates:

• Cloudflare Static Assets/Pages: near-zero platform and delivery cost under current pricing.
• Sevalla Static: within the published free 100 GB allowance and fair use.
• Surge Free: viable for a straightforward static site under its terms.
• Netlify Free: 20 GB alone would consume about 400 credits, already above the 300-credit Free pool before builds or requests.
• Vercel Hobby: price is $0, but commercial use is outside the plan; Pro establishes a $20/developer floor.
• GitHub Pages: not intended as free hosting for an online business.

Winner: Cloudflare for the lowest-cost commercial edge/static default; Sevalla is a strong conventional static alternative.

Scenario 2: one always-on 512 MB API, low traffic

Representative monthly compute floors:

Platform	Approximate monthly floor	What is included or excluded
DigitalOcean App Platform	$5	Fixed 512 MiB service and plan transfer allowance
Back4app shared container	$5	0.5 CPU, 512 MB, 100 GB transfer
Koyeb Micro	About $5.36	0.5 vCPU, 512 MB; transfer allowance
Fly.io shared 512 MB	About $3.32	Machine only; volume, IP, and egress extra
Heroku Basic	$7	512 MB dyno; add-ons separate
Render Starter	$7	512 MB paid web service; workspace/data extras
AWS Lightsail Container Nano	$7	0.25 vCPU, 512 MB, 500 GB/service
Railway 0.5 vCPU/0.5 GB	About $15.22	Usage-based CPU/RAM before egress/storage
Bunny 1 vCPU/1 GB	About $18.25	One always-active instance before traffic/IP/storage

The comparison is not performance-normalized. CPU shares and scheduling differ. It shows why usage pricing can be more expensive than a fixed plan when a service is continuously allocated.

Winner: DigitalOcean App Platform or Back4app for predictable tiny always-on cost; Fly.io when placement/control matters; Railway when project-level developer experience is worth the resource meter.

Scenario 3: bursty API, 50,000 requests/month, 100 ms average CPU, no minimum instance

A scale-to-zero runtime can remain inside the free grants of Cloudflare Workers, Cloud Run, Lambda, Azure Functions, or IBM Code Engine, depending on memory, CPU, duration, and request shape.

The app may still pay for:

• Database compute and storage
• Connection pooling
• Logging and traces
• Object storage operations
• Outbound data
• Custom domains, WAF, or API gateway

Winner: Cloudflare Workers for web-standard edge logic and low egress risk; Cloud Run for an ordinary container; Lambda/Azure Functions for native event ecosystems.

Scenario 4: 100 GB/month public delivery

• Cloudflare Workers/Static Assets: no separate Workers egress charge.
• Vercel Pro: within its checked 1 TB transfer allowance, but the plan floor remains.
• Deno Pro: within 200 GB, but $20 plan floor.
• Back4app $5: exactly within 100 GB published allowance.
• Lightsail Containers: within 500 GB.
• Bunny Magic Containers in Europe/North America: about $1 of traffic, plus compute.
• Fly.io in North America/Europe: about $2 of egress, plus machines.
• Railway: about $5 of egress, plus CPU/RAM.
• Amplify: roughly $12.75 after a 15 GB allowance at $0.15/GB, before other meters.
• Firebase Hosting: roughly $13 or more after its daily allowance, before other services.

Winner: depends on compute. Cloudflare is the network-cost reference; Back4app and Lightsail can include transfer inside a fixed small service; Bunny is a low-rate global container alternative.

Scenario 5: SaaS with frontend, API, Postgres, worker, cron, and previews

Three credible architectures:

Bundled PaaS: Railway, Render, Northflank, or Upsun. One service graph and bill, easier private networking, less operational work.

Split serverless: Vercel/Cloudflare + Supabase/Neon + Trigger.dev/Inngest + object storage. Excellent component specialization, more vendors and cross-service failure modes.

One-server PaaS: Coolify/Dokploy on a VPS plus off-site backups. Lowest cash floor, highest owner responsibility and shared blast radius.

Winner: Railway/Northflank for the first product iteration; split architecture when a component has a strong reason; self-hosting when cash efficiency and operational control outweigh managed convenience.

Scenario 6: GPU-backed AI demo

• Hugging Face Spaces: easiest public demo and model-community integration.
• Modal: strongest programmatic serverless Python/GPU workflow.
• Cloud Run GPU or hyperscaler container services: more cloud control, more configuration.
• Self-hosted GPU server: stable cost at sustained utilization, but capacity and operations are yours.

Winner: Hugging Face for a showcase; Modal for a product pipeline; own GPU capacity when sustained utilization justifies it.

Best platform by use case

Best Vercel alternative

• Cloudflare for edge/static economics.
• Netlify for the closest frontend workflow.
• Railway or Render for an ordinary backend server.
• Coolify for self-hosting.
• Firebase App Hosting or Amplify for parent-cloud integration.

Best Railway alternative

• Northflank for a rich service graph.
• Render for fixed-size Heroku-like services.
• DigitalOcean App Platform for predictable small plans.
• Koyeb for low-use global containers.
• Coolify/Dokploy for one-server economics.

Best free commercial static hosting

Cloudflare Static Assets/Pages and Sevalla Static are the cleanest defaults in this comparison. Surge is excellent for CLI-first static publishing. Verify terms and fair use for the exact workload.

Best tiny commercial API

DigitalOcean App Platform, Back4app, Koyeb, Lightsail Containers, Fly.io, Railway, and Render Starter form the practical shortlist. Fixed plans suit continuous use; scale-to-zero suits idle use.

Best background jobs

Trigger.dev, Inngest, Cloud Run Jobs, Azure Container Apps Jobs, IBM Code Engine Jobs, Modal, Railway workers, and Render workers.

Best for Laravel and PHP

• Laravel Cloud for the least operational friction and first-party managed workflow.
• Laravel Forge for a normal VPS or cloud server with predictable long-running processes.
• Laravel Vapor for Lambda-based serverless Laravel in the customer's AWS account.
• Ploi or RunCloud for broader PHP server management.
• CloudPanel for a free control panel when the operator accepts full server responsibility.

Best for Elixir, R, and WebAssembly

• Gigalixir for Phoenix/Elixir deployment with framework-aware operations.
• Posit Connect Cloud for the broadest managed R/Python data-app and document workflow.
• shinyapps.io for the established R Shiny-specific publishing workflow.
• Fermyon Cloud for Spin-based WebAssembly services.
• Wasmer Edge for another Wasm-oriented edge path with broader package/runtime ambitions.

Best for Europe

Koyeb, Scaleway Serverless Containers, Scalingo, Clever Cloud, Upsun, alwaysdata, Sliplane, Laravel Cloud's available European regions, and European regions of global platforms. Choose based on data residency, egress destination, and database region, not company headquarters alone.

Best for Spain

For self-hosting, pair Coolify/Dokploy/Kamal with a Spain-region or Barcelona/Madrid VPS from the VPS comparison. For managed platforms, use the nearest European region and verify where the database and backups live.

Best self-hosted PaaS

Coolify is the broad general-purpose default. Dokploy is excellent for Compose and multi-server workflows. Easypanel is polished for a few projects. CapRover and Dokku are mature one-server options. Kamal is best when a control plane is unnecessary. For Laravel/PHP, add Forge, Ploi, RunCloud, and CloudPanel. For a curated catalog of packaged self-hosted apps, add Cloudron.

Best own-cloud platform

Porter for a managed PaaS layer on customer cloud, Qovery for governed Kubernetes, Flightcontrol for AWS-focused deployment, Cloud 66 for managed servers/Rails, Encore for opinionated backend automation, and SST for code-first own-cloud infrastructure.

Decision tree

Step 1: Is the output static after build?

• Yes, and commercial: start with Cloudflare, Sevalla Static, Netlify, or Surge.
• Yes, and documentation/open source: add GitHub Pages or GitLab Pages.
• No: continue.

Step 2: Does the application require a conventional long-running server?

Examples: WebSockets, custom native binary, stable process memory, long HTTP request, background loop.

• Yes: Railway, Render paid, Fly.io, DigitalOcean App Platform, Back4app, Koyeb, Northflank, Lightsail Containers, Laravel Cloud, or a self-hosted/server-managed path such as Coolify, Forge, Ploi, RunCloud, or CloudPanel.
• No: continue.

Step 3: Can it scale to zero without harming user experience?

• Yes, web-standard edge code: Cloudflare Workers or Deno Deploy.
• Yes, ordinary container: Cloud Run, Azure Container Apps, IBM Code Engine, Scaleway Serverless Containers.
• Yes, function/event model: Lambda, Azure Functions, Cloud Run functions, Val Town.
• No: choose a fixed/always-on service.

Step 4: Is persistent local disk required?

• Yes: prefer an always-on container/VM and design backups/replication.
• No: use object storage or a managed database and keep app instances stateless.

Step 5: How much outbound traffic will the app send?

• Under 10 GB: compute and plan floor usually matter more.
• 10-500 GB: bundled allowances can decide the winner.
• Above 500 GB: compare Cloudflare, Bunny, Fly.io, included-transfer fixed plans, and a CDN architecture before choosing a high-overage frontend cloud.

Step 6: Is operating Linux acceptable?

• Yes: price a VPS plus Coolify/Dokploy/Easypanel/CapRover/Dokku/Kamal, or a PHP-oriented panel such as Forge/Ploi/RunCloud/CloudPanel, plus off-site backup.
• No: stay with managed PaaS/serverless.

Step 7: Does the infrastructure need to stay in your cloud account?

• Yes: Porter, Qovery, Flightcontrol, Cloud 66, Encore, SST, or direct cloud services.
• No: bundled PaaS is often simpler and cheaper for a small team.

Portability and migration checklist

Before committing, verify:

1. The application can build from a standard Dockerfile or standard framework output.
2. Configuration is exportable as code, not only dashboard state.
3. Environment variables and secrets can be exported securely.
4. The database supports logical backup and restore to another provider.
5. Object storage has a bulk export path and portable API.
6. Domains and certificates are not tied to an inaccessible account.
7. Background jobs and schedules are documented outside the platform UI.
8. Logs and metrics can be exported.
9. The app does not depend unnecessarily on proprietary middleware or edge APIs.
10. A migration has been rehearsed before an emergency.

Portability tiers

High portability: ordinary Docker container, external Postgres, S3-compatible objects, documented cron/jobs, open telemetry.

Medium portability: framework adapter plus platform functions and managed database with export.

Low portability: proprietary edge APIs, tightly coupled BaaS data model, dashboard-only workflows, no tested export, and platform-specific state.

Low portability is not automatically bad. It can buy speed. It should be an explicit trade.

Frequently asked questions

What is the best Vercel alternative in 2026?

Cloudflare is the strongest low-cost edge and static alternative, Netlify is the closest broad frontend-workflow alternative, Railway and Render are stronger for ordinary long-running backends, and Coolify is the leading self-hosted route. The best choice depends on whether the app needs Next.js-specific behavior, a persistent server, a database, or scale-to-zero.

Is Railway cheaper than Vercel?

For a full-stack app with an ordinary container and database, Railway can be easier to model because CPU, RAM, storage, and egress are explicit. For a cached frontend with light functions, Vercel may be cheaper or operationally simpler. They are not equivalent products.

Is Render really free?

Render offers free evaluation resources, but free web services sleep after 15 minutes and free PostgreSQL databases expire after 30 days. It is suitable for demos and testing, not a substitute for an always-available paid production stack.

Which platform has the cheapest egress?

Cloudflare Workers does not add a separate egress charge, while Bunny Magic Containers charges $0.01/GB in Europe and North America and Fly.io starts around $0.02/GB in those regions. Included allowances can make Vercel, Deno, Back4app, or Lightsail cheaper at a specific traffic level.

Does serverless mean zero cost when idle?

Not always. Functions and scale-to-zero containers can reach zero compute instances, but minimum replicas, databases, storage, logs, static IPs, NAT, load balancers, build artifacts, and reserved concurrency can continue billing.

Can a serverless platform run background workers?

Some can, but request functions often have duration and lifecycle limits. Cloud Run jobs, Azure Container Apps jobs, IBM Code Engine jobs, Modal, Trigger.dev, Inngest, and ordinary Railway/Render workers are more appropriate for long or durable background work.

What is the cheapest way to host many small apps?

A single VPS with Coolify, Dokploy, Easypanel, CapRover, Dokku, or Kamal can have the lowest cash cost when the apps fit comfortably on one server. The tradeoff is shared failure risk and responsibility for updates, backups, monitoring, and recovery.

Should a hobbyist use Kubernetes?

Usually not for one or two small applications. Kubernetes becomes reasonable when its scheduling, policy, portability, and multi-team controls solve real problems. Kubero, Porter, and Qovery are valuable, but a small PaaS or one-server Docker panel is simpler and often cheaper.

Which free tiers allow commercial projects?

Terms differ. Vercel Hobby is explicitly non-commercial, GitHub Pages is not intended as free hosting for an online business, and alwaysdata Free is personal. Cloudflare Workers, provider static-site offers, and some PaaS free tiers can be used under their service terms, but quotas and acceptable-use policies still apply.

Which platform is best for a small always-on API?

DigitalOcean App Platform, Back4app Containers, Koyeb, Fly.io, Heroku Basic, Render Starter, Railway, and AWS Lightsail Containers are all plausible. Fixed plans favor predictable use; usage billing favors bursty use. Location, memory, transfer, and database needs decide the winner.

Which platform is best for Next.js?

Vercel remains the path of least resistance for the complete Next.js feature set. Cloudflare, Netlify, Deno, Firebase App Hosting, Amplify, Railway, Render, and self-hosted Node containers are alternatives, but framework feature parity and runtime behavior must be tested.

Which is best for Laravel: Laravel Cloud, Forge, or Vapor?

Laravel Cloud is the managed server-based path and can scale supported resources to zero; Forge manages servers in your own provider account; Vapor deploys Laravel to AWS Lambda and adds AWS charges to its subscription. Choose by runtime and operations model, not by the shared Laravel branding.

Which platform is best for R and Python data apps?

Posit Connect Cloud is the broad managed publishing choice for Shiny, Streamlit, Dash, Bokeh, Quarto, R Markdown, and Jupyter. shinyapps.io remains a focused Shiny option, Streamlit Community Cloud is convenient for public Streamlit projects, and Hugging Face Spaces is strongest when the application centers on models or demos.

Is a server management panel the same as a PaaS?

No. Forge, Ploi, RunCloud, CloudPanel, Coolify, and Dokploy simplify deployment and server administration, but the customer still owns the server bill and much of the security, backup, capacity, and recovery responsibility. A hosted PaaS usually bundles more of that operational boundary.

What is the difference between PaaS and BYOC?

A conventional PaaS runs workloads in the vendor account and bills a bundled service. BYOC control planes deploy into the customer AWS, Azure, GCP, Kubernetes, or VPS account. BYOC improves ownership and escape paths but creates a platform fee plus native cloud costs.

Are platform databases cheaper than external databases?

Sometimes at small scale because setup and private networking are easier. At larger scale, an independent database such as Supabase, Neon, Turso, MongoDB Atlas, or a cloud managed database can be more capable or portable. Compare compute, storage, I/O, backups, transfer, connection limits, and restore procedures.

How do I prevent a surprise serverless bill?

Set platform budgets and hard caps where available, separate production from experiments, cap autoscaling and concurrency, monitor egress and logs, avoid accidental minimum instances, and load-test with billing telemetry enabled. A spend alert is not always a spend limit.

How often should this comparison be updated?

Quarterly at minimum and immediately after free-tier, egress, seat, credit, or lifecycle changes. The deployment market changes quickly; App Runner, Deno Deploy Classic, Shuttle, Glitch, Heroku, and Flightcontrol show why lifecycle verification matters.

Bottom line

The deployment market is best understood as a set of billing and execution models, not a popularity contest.

• Vercel Pro is the best commercial Next.js experience when framework integration is worth the seat and usage model.
• Cloudflare Workers and Static Assets are the best low-cost edge/static default and the network-price reference.
• Railway is the best approachable usage-metered full-stack PaaS.
• Render is the best-known free evaluation path, not a promise of free production.
• DigitalOcean App Platform and Back4app are excellent predictable tiny always-on options.
• Fly.io is the strongest small-team distributed-machine platform when the state model is understood.
• Google Cloud Run is the best mainstream portable scale-to-zero container reference.
• Modal, Val Town, Pipedream, Trigger.dev, and Inngest solve specialized compute and workflow problems better than a generic web host.
• Laravel Cloud, Forge, and Vapor are three strong Laravel paths, but they represent managed server-based, owned-server, and AWS serverless architectures respectively.
• Gigalixir, Posit Connect Cloud, shinyapps.io, and Fermyon Cloud are credible specialist choices when Elixir, R/Python data publishing, Shiny, or WebAssembly is the product's center of gravity.
• Coolify and Dokploy provide the best cash-cost route for many small apps on owned servers, while Forge, Ploi, RunCloud, CloudPanel, and Cloudron cover important server-management niches.
• Porter, Qovery, Flightcontrol, Cloud 66, Encore, and SST are ownership and governance choices, not automatically cheap hobby hosting.

The correct process is simple even when the market is not:

1. Define the workload shape.
2. Estimate idle and active compute separately.
3. Add database, storage, builds, logs, network, and seats.
4. Check commercial-use and lifecycle terms.
5. Test the exact region and runtime.
6. Preserve an exit path.

A platform that costs $0 for a static portfolio can cost hundreds for an SSR-heavy commercial app. A $5 VPS can host dozens of small services or become an expensive source of incidents. The best choice is the architecture whose limits remain acceptable when the product succeeds.

Official sources checked

The detailed tables link each product to its official pricing, product, or documentation page. The most load-bearing sources include:

• Vercel pricing
• Netlify pricing
• Cloudflare Workers pricing
• Cloudflare Containers pricing
• Deno Deploy pricing
• Railway pricing
• Render pricing
• Fly.io pricing
• DigitalOcean App Platform pricing
• Google Cloud Run pricing
• AWS Lightsail pricing
• AWS Elastic Beanstalk pricing
• Azure Container Apps pricing
• Bunny Magic Containers pricing
• Coolify pricing
• Dokploy pricing
• Laravel Cloud pricing
• Laravel Forge pricing
• Laravel Vapor pricing
• Ploi pricing
• RunCloud pricing
• CloudPanel
• Cloudron pricing
• Fermyon Cloud pricing
• Gigalixir pricing
• shinyapps.io pricing
• Posit Connect Cloud plans
• AWS App Runner availability notice
• Deno Deploy Classic shutdown information
• Shuttle shutdown notice
• Glitch hosting shutdown notice

Update policy

Recheck this article at least quarterly and immediately after a provider changes:

• free-tier commercial-use rules;
• seat, credit, build, transfer, or function pricing;
• sleep, scale-to-zero, or minimum-instance behavior;
• database retention or backup policy;
• lifecycle status, ownership, or product name;
• region availability or data residency;
• transfer allowances and overage rates.

Do not silently preserve an old price when a current official page is dynamic or contradictory. Record the discrepancy and let the provider console or contract control the purchase.