Buyer’s Guide

Best Hosting Platforms for Developers

Written by Govind Kumar Lohar. Reviewed for technical accuracy by Deepak Gupta and Bhaskar Suthar on · Review panel

  • hosting
  • paas
  • serverless
  • edge

Independent buyer’s guide. No vendor paid to be included, ranked or described a particular way. Written for engineers, architects and the people who sign off on their tooling budget. Editorial policy.

Hosting comparisons are the most crowded content on the internet and almost all of it is useless, because it ranks platforms that are not competing for the same job. Putting Cloudflare Workers next to Hetzner in a table implies you are choosing between them. You are not. You are choosing an abstraction level first, and only then a vendor inside it.

The abstraction level is the decision that sticks. Every rung on the ladder takes something away from you in exchange for removing operational work, and the thing it takes away is usually the thing you discover you needed eighteen months later. Static hosting takes away the server. Functions take away the long-lived process. Edge runtimes take away most of Node. Containers give the process back and hand you orchestration in return. A VPS gives everything back and hands you the pager.

The second thing that sticks is the meter. Platforms at different abstraction levels charge on structurally different units, which is why a spreadsheet comparing them is always wrong. Bandwidth, build minutes, request count, GB-seconds, container-hours and flat monthly instance rent do not convert into each other without knowing your traffic shape, and your traffic shape is the one thing the pricing page cannot see.

So this is a map, not a leaderboard: what each abstraction removes, what it meters, the costs that are real but never on the pricing page, and a decision procedure that routes you to the specific guide for your situation.

Key takeaways

  • Choose the abstraction before the vendor. Moving between vendors inside one abstraction is a weekend; moving between abstractions is a rewrite of your deployment, your background jobs and your local development story.
  • Every platform meters something different. Normalise to your own traffic shape before comparing anything, because bandwidth, build minutes and request counts are not interchangeable units.
  • The constraint that matters is what you cannot run, not what you can. Long-lived connections, background workers, filesystem writes and native binaries are where platform choices break.
  • Exit cost is the underpriced variable. A platform whose primitives are a container and a Postgres connection string is cheap to leave. A platform whose primitives are proprietary is not.

The ladder, and what each rung takes away

Static hosting serves files from a CDN. There is no server, no runtime and no state. It takes away every server-side capability, which is why it is the cheapest, fastest and most reliable thing on this list. Anything dynamic becomes someone else’s API. The failure modes are limited to build failures and cache invalidation, and that narrowness is the product. Covered in static site hosting.

Platform as a service runs your process. You push a git branch, the platform detects your stack, builds an image and runs it behind a router with TLS and a health check. It takes away the build pipeline, the load balancer, the certificate rotation and the init system. What it takes away that you will notice: control over the base image, the ability to SSH in and look, and in most cases anything that needs a persistent local disk. Covered in PaaS platforms.

Container hosting runs an image you built. It takes away the scheduler and the node management, but it gives back the base image, the filesystem inside the container and the process model. This is the rung where “it works in CI” becomes a meaningful guarantee, because the artefact is the same everywhere. Covered in container hosting platforms.

Functions run a handler. There is no long-lived process, so there is no in-memory cache that survives, no background worker, no connection pool that you control, and no WebSocket you hold open. In exchange you stop paying for idle and you stop thinking about capacity entirely. The tax is cold starts and the database connection problem. Covered in serverless function platforms and, for the cold start question specifically, serverless cold starts.

Edge runtimes run a handler in many locations at once, usually on an isolate-based runtime rather than a container. They take away most of Node: filesystem access, native modules, and frequently large parts of the standard library. They also take away the assumption that your database is nearby, which is the single most common way an edge deployment ends up slower than the regional one it replaced. Covered in edge compute platforms and the three-way Workers vs Vercel vs Deno Deploy comparison.

VPS and bare metal give you a machine. Nothing is taken away, which is the point and also the bill: you now own kernel updates, TLS renewal, backups, monitoring, log rotation and the 3am page. The economics are dramatically better and the honest version of that maths includes engineer hours. Covered in VPS and bare metal providers.

What each rung meters

This is where comparison actually breaks down, so be precise about it.

Static hosts meter bandwidth served and build minutes consumed. Both are invisible until a post gets traffic or a monorepo build starts taking twenty minutes on every branch.

PaaS platforms meter instance size multiplied by time, usually with a separate meter for managed database add-ons and another for bandwidth. The bill is predictable, which is most of why people pay the premium.

Container platforms meter vCPU and memory allocated per second, sometimes only while a request is in flight and sometimes continuously. Whether you pay for idle is the single biggest difference between two container platforms that look identical on paper.

Function platforms meter invocations and GB-seconds of execution. This is the meter most sensitive to architecture: splitting one endpoint into five does not change your traffic but can change your bill.

Edge platforms meter requests, CPU milliseconds and often a separate charge for any state you touch, because KV, object storage and durable state are priced independently from compute.

VPS providers meter a flat monthly rent per machine, with bandwidth either included up to a generous allowance or billed separately. The flatness is the feature.

The cross-cutting meter is egress. Object storage and CDN egress is where cloud bills go strange, and it is priced so differently between providers that it deserves its own analysis. See S3 alternatives and CDN providers, and for a like-for-like framing across providers, cloud cost compared.

Three costs that are never on the pricing page

Build minutes on a monorepo. Every platform advertises generous build minutes and every monorepo eats them, because a naive setup rebuilds everything on every branch push. This is a caching problem before it is a pricing problem, and it is why build caching and monorepo build tools are load-bearing for hosting costs.

The database connection. Functions and edge runtimes scale horizontally without limit, which means they open connections without limit, which means Postgres falls over long before your compute does. The fix is a pooler or a database with an HTTP interface, not a bigger instance. See Postgres connection poolers, serverless databases and, for edge specifically, edge databases.

The exit. Ask what the platform’s primitives are. If they are a container image, a Postgres URL and environment variables, leaving is a weekend. If they are proprietary routing, proprietary caching semantics and a framework adapter nobody else implements, the exit is a project. This is the actual subject of both Vercel alternatives and Heroku alternatives.

Needs first-hand data: Deploy one identical application, a small API with a Postgres dependency and a background job, to one platform on each rung. Record time from empty repository to production URL, lines of configuration required, and what had to be removed or rewritten to make it run. The rewrite column is the one nobody publishes.

How to choose

Work down this list and stop at the first answer that is a hard yes.

Does it need to be online with no server-side code? Static hosting. The decision is then bandwidth pricing at your scale and how redirects and headers are configured, not features. Go to static site hosting.

Is it a Next.js application? The framework constrains the platform more than the platform constrains the framework, because ISR, image optimization and middleware each need specific support. Go to hosting for Next.js.

Is it Python, specifically FastAPI or a worker-heavy Django app? The async worker model and the dependency install time change the answer. Go to hosting for Python.

Do you need long-lived connections, background workers, or a process that holds state between requests? You need a process, so you are choosing between PaaS and containers. Start at PaaS platforms, and if you already build images in CI, go straight to container hosting.

Is your traffic spiky with long idle periods? Functions, because paying for idle is the thing you are trying to avoid. Go to serverless function platforms and read cold starts before committing.

Is the work genuinely latency-bound at the network edge, meaning auth checks, redirects, personalisation and A/B splits rather than data-heavy rendering? Edge. Go to edge compute platforms.

Do you have users on more than one continent and a database that cannot move? This is a data locality problem wearing a hosting costume. Go to multi-region deployment.

Are you training or serving models? A completely separate market with its own supply constraints. Go to GPU cloud providers.

Is the bill the reason you are reading this? Go to VPS and bare metal for the honest version of the maths, including the hours you take back on.

Are you pre-revenue and optimising for speed to first deploy? Go to hosting for startups, which is mostly about which free tier stops being free first.

Two supporting decisions sit underneath all of these and are worth making deliberately rather than by default: DNS providers, because DNS is the control plane for every migration you will ever do, and CDN providers, because the CDN in front of your origin is frequently a better performance investment than moving the origin.

AbstractionWhat it removesWhat it metersWhere it breaks
StaticThe server entirelyBandwidth and build minutesAnything dynamic becomes another service
PaaSBuild pipeline, router, TLS, initInstance size times timePersistent disk, custom base image, cost at scale
ContainersScheduler and node managementvCPU and memory per secondYou now own the image and its CVEs
FunctionsThe long-lived processInvocations and GB-secondsConnections, cold starts, no background work
EdgeMost of Node, and locality assumptionsRequests, CPU time, state separatelyYour database is suddenly far away
VPSNothingFlat monthly rent per machineYou own the pager

Needs first-hand data: Take one real application already in production and measure a month of traffic in every unit at once: GB egressed, build minutes consumed, requests served, CPU milliseconds burned, container-seconds running, and peak concurrent database connections. That single normalisation table converts any vendor quote into any other vendor’s unit, and nobody publishes it.

Frequently asked questions

Should I just use AWS directly?

If you have a platform team, yes, and you will not be reading a hosting comparison. If you do not, the managed platforms here are selling you the thing AWS does not: an opinion. The cost premium is real and it buys you not having to decide between six ways to run a container. Revisit the question when the premium exceeds a salary.

Is serverless cheaper?

It is cheaper when you are idle and more expensive when you are busy, and the crossover point depends on your utilisation rather than your traffic. A service running at high steady utilisation is almost always cheaper on a rented machine. A service that is idle twenty hours a day is almost always cheaper on functions. Measure utilisation, not requests.

How much does moving platforms actually cost?

Inside one abstraction, very little, assuming you did not adopt proprietary primitives. Across abstractions it is a rewrite of deployment, background jobs, local development and often the database access pattern. This is the argument for picking the abstraction carefully and the vendor casually, rather than the reverse.

Do I need multi-region on day one?

Almost certainly not. Multi-region compute with a single-region database usually makes latency worse, because every dynamic request now crosses an ocean to reach the data. Fix your CDN and your cache headers first; that solves most of what people think is a multi-region problem.