Buyer’s Guide

Best Container Hosting Platforms

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

  • hosting
  • containers
  • serverless
  • kubernetes

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.

There is a category of product that sits between a virtual machine and a function: you hand it an image, it runs the image, and it handles placement, health checking, rolling deploys, TLS and autoscaling. No cluster to bootstrap, no control plane to upgrade, no node pool to right-size. For most teams most of the time, this is the correct place to run a web service, and it is under-chosen because Kubernetes takes up all the oxygen.

The three things that actually differentiate these platforms are not on any feature page. The first is what happens when traffic stops: whether the platform can drop you to zero instances, how long it takes to come back, and whether that recovery is a container start or a full image pull. The second is what the meter is measuring, because “per GB-second” describes at least two different billing mechanisms and the difference between them can be several multiples of the same workload’s cost. The third is how much of a scheduler you are getting, because a platform that runs your container is a smaller thing than a platform that runs your cluster, and the gap between them is where migrations die.

The rest of this is mostly about those three. The product blocks near the end matter less than getting these right, because a platform you chose for the wrong billing model is a platform you will leave.

Key takeaways

  • Scale to zero converts a fixed monthly cost into a per-request latency penalty. Whether that is a good trade depends entirely on how often your traffic actually hits zero, which most teams have never measured.
  • Per-GB-second billing has two variants. Request-time billing charges only while a request is in flight; allocated-time billing charges for every second an instance exists. The same service can differ enormously between the two.
  • Concurrency per instance is the most powerful cost lever on request-billed platforms, because it divides the instance-seconds across the requests that shared them.
  • A container platform gives you a constrained deployment surface in exchange for not operating a control plane. If you need node-level access, custom controllers or per-node agents, you need a scheduler, and you should find that out before you migrate.

Scale to zero, and the cold start you traded for it

Scale to zero means the platform is allowed to run no instances of your service when nothing is asking for it, and to start one when a request arrives. It is the single feature that makes a container platform feel like serverless, and its cost is entirely in the resume path.

That path has four phases and they are not equally expensive.

Image pull. If the image is not already cached on the machine that will run it, the platform fetches it from a registry. This scales directly with image size and with how well the layers are cached, and it is usually the largest single term in a bad cold start. A container image that carries a full build toolchain and a package manager cache behaves very differently here from a distroless image containing a static binary. This is the phase you have the most control over and the one teams most often ignore.

Sandbox start. Creating the isolation boundary: a container on a shared kernel, or a microVM with its own. MicroVMs boot a kernel and are structurally slower to start than a namespace-and-cgroup container, though the good implementations have compressed this a long way with snapshotting. Platforms differ here by architecture, and it is the phase you cannot influence at all.

Process start and runtime boot. Your language runtime initialising. A JVM and a static Go binary are in different worlds, and this is why the same platform gets described as fast by one team and slow by another. It is also where most of the achievable improvement lives after image size.

Readiness. The gap between the process existing and the process being able to serve. Connection pools opening, configuration fetched, caches warmed, a migration check run at boot. Plenty of services spend more time here than in the other three phases combined, and most of that is application code nobody has looked at in a year.

The important consequence: cold start is mostly your problem, not the platform’s. Image size and boot work are yours. The platform contributes the sandbox start and the scheduling decision. When comparing platforms on cold start, compare with the same image or you are measuring your own Dockerfile.

The other important consequence: scale to zero is not free even when nothing is running. Every request that arrives to a cold service pays, and if your traffic is a trickle rather than a genuine zero, you can end up paying the cold start repeatedly while never actually saving much, because the instance was only idle for a minute at a time. Most platforms offer a minimum instance count precisely for this, and setting it to one converts the platform back into a conventional always-on host with a usage bill.

Needs first-hand data: Instrument your own service’s boot and record the four phases separately: image pull, sandbox start, process start, and time to first successful health check. Do it for your production image and for a stripped-down one. The split tells you whether cold start is a platform problem or a Dockerfile problem, and in most cases it is the second.

What per-GB-second actually meters

Nearly every platform here prices on some combination of vCPU-seconds and GB-seconds. That sounds like one model. It is at least two, and the difference decides your bill.

Allocated-time billing charges for every second an instance exists, from start to shutdown, at the CPU and memory you configured. If an instance is up for an hour and served four requests, you pay for an hour. This is how conventional container runtimes bill, and it is straightforward to reason about: your cost is instance count multiplied by uptime multiplied by size.

Request-time billing charges only for the time an instance is actively handling a request, sometimes with an added allowance either side. An instance that is up but idle costs nothing or nearly nothing, and CPU may be throttled or removed entirely outside a request, which matters enormously if you were planning to do background work between requests.

Three consequences follow from that split, and all three surprise people.

Concurrency is a cost divider under request-time billing. If one instance handles many simultaneous requests, the instance-seconds those requests consume are shared. Doubling the concurrency ceiling on an I/O-bound service can nearly halve its compute bill, because the instance was mostly waiting anyway. This is the most under-used cost lever in the category, and it is free to try.

Background work breaks under request-time billing. A timer that fires between requests, a queue consumer polling in a goroutine, a metrics flush on an interval: all of these assume CPU is available when no request is in flight. On a request-billed platform, CPU may be throttled to near nothing outside requests, so that code runs at some unpredictable slow rate or not at all. The symptom is telemetry going missing and background jobs silently falling behind, and it is the same class of failure that breaks APM agents on serverless.

Memory is usually the binding constraint, not CPU. Most platforms tie CPU allocation to memory in steps, so a service that needs more CPU gets it by asking for memory it does not use. Sizing by measured memory alone often leaves you CPU-starved under load, and the fix costs money in the dimension you were not looking at.

A fourth thing to check, which is not billing but behaves like it: minimum billable granularity. Some platforms round each instance’s life up to a floor. A service with short bursts of traffic and a small floor is cheap; the same service with a large floor is not. Ask for the rounding rule, because it does not appear in the headline rate.

A container platform is not a scheduler

This is the distinction that causes the most failed migrations, and it is simple once stated.

A scheduler is Kubernetes, Nomad, or ECS in its full form. You get a cluster abstraction: nodes, a scheduler making placement decisions, and an extensible API. You can run per-node agents, define custom resources and controllers, express placement affinity, attach sidecars to every pod by policy, run privileged workloads, and reach the host. You also operate a control plane, or pay someone to, and you own the upgrade path.

A container platform is the managed product that runs your image. You get a service abstraction: an image, a port, some environment variables, a scaling rule, a domain. The platform decides where it runs and you do not get to ask. In exchange you have no control plane, no node pool, no upgrade cycle and no cluster autoscaler to tune.

The gap shows up in a specific list of things, and it is worth reading before you commit:

  • No per-node agents. A log shipper or security agent that runs on every node has nowhere to live. Telemetry has to come from inside the application, which is a different integration for most vendors.
  • Sidecars are limited or absent. Some platforms here support multiple containers per unit, some do not. A service mesh proxy, a database auth proxy or a log sidecar may or may not be expressible.
  • No custom controllers. Operators, custom resources and anything that extends the scheduler’s own API do not exist. If your database is deployed by an operator today, it is not coming with you.
  • Placement is not yours. No node affinity, no taints and tolerations, no spreading rules beyond what the platform exposes as a region or zone setting.
  • Stateful workloads are second-class. Persistent volumes exist on some of these platforms and are usually zonal, single-attach and awkward with scaling. A stateful set with ordered rolling updates and stable network identities is a scheduler feature.
  • Startup and shutdown hooks are simpler. Readiness and liveness probes are usually there; pre-stop hooks, graceful termination windows and init containers vary.

None of that is an argument against container platforms. Most services need none of it, and running a cluster to get features you do not use is the more common mistake by a wide margin. The point is to check the list against your actual deployment manifests before you start, because discovering a missing primitive halfway through a migration is expensive. The deployment tooling question around all of this is covered separately in deployment orchestration tools.

OCI images: the standard underneath, not a product

Everything on this page consumes the same artifact format, and that is not an accident. The OCI image specification defines what a container image is: a manifest, a set of compressed filesystem layers, and a configuration blob describing the entrypoint, environment and metadata. A separate specification defines how registries serve those artifacts, and a third defines how a runtime turns a filesystem bundle into a running process.

It is a specification, not a vendor. There is no bill and nothing to evaluate. What it changes is your negotiating position.

What it gives you

  • Genuine portability of the artifact. The same image runs on every platform below, on your laptop, and in CI, which makes the deployment target a smaller decision than it would otherwise be.
  • Layer-level caching and deduplication, which is the mechanism behind fast rebuilds and fast image pulls, and the reason Dockerfile layer ordering has an outsized effect on cold start.
  • Content-addressable digests, so the image that passed CI and the image running in production can be proven identical rather than assumed, which is the foundation for provenance and supply chain security.
  • A registry API that every platform speaks, so your build pipeline does not need a per-platform publishing step.

What it does not do

  • It standardises the artifact, not the runtime environment. Environment variables, secret injection, health check semantics, networking model and filesystem writability all differ per platform and none of them are in the spec.
  • It says nothing about how the image is built, so reproducibility, provenance attestation and signing are separate concerns layered on top.
  • Multi-architecture images are expressible and are not automatic, and a single-architecture image deployed to a platform running a different processor family fails in a way that reads as a platform bug.
  • Portability of the image does not mean portability of the application. Your scaling configuration, ingress rules, secret bindings and volume definitions are platform-specific and are usually more work to move than the image itself.

Google Cloud Run

Cloud Run is the most fully developed implementation of the request-billed container model. You give it an image and a port, it gives you an autoscaling HTTPS service that scales to zero, and the surrounding decisions it exposes are the right ones: concurrency per instance, minimum and maximum instances, and a choice between request-time and allocated-time billing. It also runs jobs rather than only services, so batch work does not need a second product.

Pros

  • The concurrency setting is a first-class control, which makes it the easiest platform here to substantially reduce the bill for an I/O-bound service
  • Two explicit billing modes, so a service that needs CPU between requests can opt into allocated-time billing rather than fighting throttling
  • Scale to zero and minimum instances are both present, so the latency-versus-cost trade is a configuration change rather than a platform change
  • Sits inside Google Cloud, so IAM, secret management, logging and private networking to managed databases are the ones you already have

Cons

  • CPU throttling outside requests under the default billing mode breaks background timers and buffered telemetry flushes, and the symptom is missing data rather than an error
  • The surrounding Google Cloud surface is large, and getting networking, IAM and service accounts correct is a real amount of work compared with the simpler platforms here
  • Regional rather than global, so multi-region means deploying and routing to several services yourself

Best for: Teams already on Google Cloud running HTTP services with bursty traffic, who want concurrency and scale-to-zero as tunable dials rather than fixed platform behaviour.

Pricing: Metered on vCPU-seconds and GB-seconds with a choice of request-based or instance-based billing, plus a per-request charge and a free allowance. The billing mode choice, not the rate, is what moves the total.

AWS ECS Fargate

Fargate is the serverless capacity mode for ECS: you define a task with CPU and memory, and AWS runs it without you managing EC2 instances. It is the most conventional model here. Tasks are long-lived, billing is allocated-time, and there is no request-driven activation, so scale to zero means a scaling policy that drops the desired count and a request that arrives to nothing. What you get instead is the full ECS surface underneath, which is closer to a scheduler than anything else on this page.

Pros

  • Full ECS semantics including sidecars, task roles, service discovery and load balancer integration, so it is a genuine scheduler rather than a constrained service abstraction
  • IAM task roles give per-task credentials without a secret in an environment variable, which is the cleanest identity story in this comparison
  • Spot capacity is available for interruption-tolerant work, which changes the economics of batch and queue consumers
  • Deep integration with the rest of AWS networking, so private subnets, security groups and VPC endpoints behave exactly as they do for EC2

Cons

  • No request-driven scale to zero, so an idle service either costs money or is unavailable, with nothing in between
  • Task startup involves network interface provisioning and image pull and is not in the same class as the request-billed platforms here
  • Allocated-time billing at task granularity means idle capacity is paid for in full, and right-sizing is entirely your job
  • The configuration surface is large enough that a first deployment is a project rather than an afternoon

Best for: Teams already on AWS who need VPC networking, IAM task roles and sidecars, and whose services run continuously rather than in bursts.

Pricing: Allocated-time billing on vCPU and memory for the life of each task, with a discounted interruptible capacity option, plus the usual AWS charges for load balancing and data transfer.

Fly.io

Fly.io homepage

Fly runs your container as a Firecracker microVM, and its organising idea is geography. You declare which regions an app runs in and anycast routing sends each request to the nearest instance, with a built-in mechanism for replaying a request to another region when it needs to reach a primary. Machines can stop when idle and start on a request, which gives scale to zero on a microVM rather than a shared-kernel container.

Pros

  • Multi-region placement is a first-class concept rather than something you assemble from several single-region deployments
  • MicroVM isolation with per-machine control through an API, so you can treat instances as addressable resources rather than as anonymous replicas
  • Automatic stop and start on request gives scale to zero without giving up a real persistent process model
  • Persistent volumes and a straightforward path to running stateful services, which most request-billed platforms handle badly

Cons

  • Multi-region compute in front of a single primary database means write forwarding and the consistency questions that come with it, and the platform makes this easy to do without making it easy to reason about
  • Volumes are tied to a specific machine in a specific region, so a stateful service does not scale or move the way a stateless one does
  • Operating a genuinely global deployment means thinking about region-level failure and placement yourself, which is more responsibility than the single-region platforms hand you

Best for: Teams who genuinely need compute in several regions and want geographic placement as a platform primitive rather than as a deployment pipeline they build.

Pricing: Metered on machine size and running time, with stopped machines not billed for compute, plus separate metering for persistent volumes and bandwidth.

Railway

Railway homepage

Railway optimises for the shortest path from a repository to a running service. Connect a repo, it detects the stack or uses your Dockerfile, provisions databases as adjacent services with private networking already wired, and gives you a deployment. The product’s centre of gravity is the developer experience of getting something running and iterating on it, and it is very good at that.

Pros

  • Databases, caches and queues are provisioned as services in the same project with private networking configured, removing most of the connection setup work
  • Environment and preview workflows are built in, so per-branch environments do not need a pipeline you maintain
  • Usage-based metering rather than fixed instance sizes means small services cost small amounts without capacity planning
  • The configuration surface is small enough that the whole platform fits in your head, which is a real advantage when debugging

Cons

  • The simplicity comes from a narrow surface, so advanced networking, placement control and multi-region topologies are not really available
  • A platform this convenient invites you to run your production database on it, and the operational commitments for a managed database are different from those for a stateless service
  • Usage-based metering across several resources is harder to forecast than a fixed instance price, particularly as a project grows services

Best for: Small teams and side projects who want a service and its database running in an afternoon and value iteration speed over infrastructure control.

Pricing: Usage-based on CPU, memory and network across all services in a project, with plan tiers adding included usage and capabilities rather than changing the meter.

Render

Render homepage

Render sits between a PaaS and a container platform. It runs Dockerfiles and also builds from source for common runtimes, and it models the things a real application needs as distinct service types: web services, background workers, cron jobs, static sites and managed databases. That typing is the product’s strength, because a background worker on Render is a supported concept rather than a web service you tricked into not listening on a port.

Pros

  • Distinct service types for web, worker, cron and static content, so the platform understands what each thing is and scales it appropriately
  • Managed Postgres and Redis alongside application services with private networking, covering most of a conventional application’s needs in one place
  • Both source builds and Dockerfile builds are supported, so teams can adopt containers gradually rather than all at once
  • Autoscaling and health-check-driven deploys are configured in the service definition rather than assembled from pipeline steps

Cons

  • Instance-time billing on paid services means idle capacity is paid for, and the free tier’s spin-down behaviour introduces a cold start that misleads people about the paid experience
  • Less placement and networking control than the cloud-native options, which becomes limiting once compliance or private connectivity requirements arrive
  • Regional deployment with a limited set of regions, so a genuinely global topology is not what this platform is for

Best for: Teams who want a conventional web service, worker and database stack running with minimal configuration and are happy paying for always-on instances.

Pricing: Instance-time billing per service at fixed instance sizes, with managed databases and bandwidth metered separately, and a free tier whose services spin down when idle.

Azure Container Apps

Container Apps is Azure’s managed container service, built on Kubernetes and a set of open components underneath: an event-driven autoscaler, a service mesh proxy for ingress, and an optional distributed application runtime for service invocation and state. That heritage shows in the scaling model, which is the most flexible here: you can scale on HTTP concurrency, but also on queue depth, topic lag or a long list of other event sources, including down to zero.

Pros

  • Event-driven scaling on queue and stream depth rather than only HTTP concurrency, which is the correct trigger for most background workloads and rare in this category
  • Scale to zero applies to those event-driven workloads too, so a queue consumer genuinely costs nothing when the queue is empty
  • Revisions with traffic splitting are built in, so canary and blue-green deploys do not need a separate tool
  • Optional sidecar-based service invocation, state and pub/sub building blocks for teams who want them, without operating the underlying cluster

Cons

  • The abstraction leaks its Kubernetes origins, and debugging occasionally means understanding components you were promised you would not have to
  • Configuration surface is large for a managed product, and the consumption and dedicated plan distinction has meaningful behavioural differences beyond price
  • Azure-centric, so the identity, networking and monitoring integrations are strong inside Azure and add friction outside it

Best for: Teams on Azure running event-driven or queue-backed workloads that should scale to zero when the queue is empty, not only HTTP services.

Pricing: Consumption-based on vCPU-seconds and GB-seconds with a free monthly allowance, plus a dedicated plan option priced on reserved capacity for predictable workloads.

Koyeb

Koyeb homepage

Koyeb runs containers on microVMs across a global network with request-driven autoscaling and scale to zero, positioning itself as the serverless container platform for teams who want global placement without assembling it. It targets the same shape of workload as Cloudflare’s container offering and Fly, with a simpler surface than either and a deployment flow closer to a PaaS.

Pros

  • Global placement and request-driven scaling in one product, so a multi-region service does not require operating several regional deployments
  • MicroVM isolation with a deployment experience closer to a PaaS than to a scheduler, which is a rare combination
  • Scale to zero on HTTP traffic, so low-traffic services are genuinely cheap rather than nominally cheap
  • Runs both containers and source-built applications, which lowers the barrier for teams not yet containerised

Cons

  • A smaller platform than the hyperscalers, so ecosystem integrations, regional coverage and community answers to your specific error are thinner
  • Stateful workloads and persistent storage are not the focus, so databases belong elsewhere
  • Less control over placement and networking than the cloud-native options, which is the usual cost of the simpler surface

Best for: Small teams who want globally placed containers with scale to zero and do not want to operate the routing and deployment plumbing themselves.

Pricing: Usage-based on instance size and running time with scale-to-zero meaning idle services accrue no compute charge, plus separate metering for bandwidth.

Needs first-hand data: Run the same image on your three finalists for a week of real traffic and compare total cost, not rate cards. Record instance-seconds, request count, peak concurrency achieved per instance, and the number of cold starts served. Request-billed and allocated-billed platforms diverge most on exactly the traffic shape you have, which is why rate comparison is useless here.

How to choose

Measure how long your traffic is actually at zero. Pull a week of request timestamps and compute the distribution of gaps between requests. If the gaps are rarely longer than a few minutes, scale to zero saves you very little and costs you a cold start every time it triggers, and you should set a minimum instance count and stop thinking about it. If your service is genuinely idle overnight and at weekends, scale to zero is a large saving. This is a ten-minute query and it decides half the comparison.

Then decide whether you need CPU between requests. Background timers, queue polling, buffered telemetry flushes and cache warming all assume CPU exists when no request is in flight. If your service does any of those, either pick allocated-time billing or move that work to a separate always-on service. Discovering this after migration looks like missing telemetry, not like an error.

Check your manifests against the scheduler gap. Go through what you deploy today and list anything that is a per-node agent, a custom resource, a sidecar injected by policy, a stateful set, or a placement rule. Every item on that list is a reason you need a scheduler rather than a container platform.

Set the concurrency ceiling deliberately. On request-billed platforms this is the biggest cost lever available and the default is rarely optimal. Raise it until latency degrades, then back off. For an I/O-bound service the difference is large.

Match the platform to where your data already is. Cross-cloud egress and the latency of reaching a database in another provider will usually outweigh any price difference between these platforms.

Scale to zeroBilling modeSidecarsPersistent volumesMulti-region
Google Cloud RunYes, request-drivenRequest-time or allocated-timeYesLimitedDeploy per region
AWS ECS FargateScaling policy onlyAllocated-timeYesVia network storageDeploy per region
Fly.ioYes, machine stop and startMachine running timeLimitedYes, zonalFirst-class
RailwayLimitedUsage-basedNoYesLimited
RenderFree tier onlyInstance-timeNoYesDeploy per region
Azure Container AppsYes, including event-drivenConsumption or dedicatedYesYesDeploy per region
KoyebYes, request-drivenInstance running timeLimitedLimitedFirst-class
OCI image spec (standard, not a product)Not applicableNoneNot applicableNot applicableNot applicable

If you are on a hyperscaler already, use its container product and stop shopping; the networking and identity integration is worth more than any difference in the compute layer. If you need real multi-region placement, Fly or Koyeb. If your scaling signal is a queue rather than HTTP requests, Azure Container Apps is the only one here that treats that as a primary case. If you want the least configuration between a repository and a running service, Railway or Render, understanding that you are paying for always-on instances. The wider set of options, including the PaaS and function platforms this category shades into, is in hosting platforms for developers.

Frequently asked questions

Does scale to zero save money?

Only when your traffic genuinely reaches zero for meaningful stretches. If requests arrive every few minutes, the platform may keep an instance warm anyway or restart one repeatedly, and you pay cold start latency without saving much compute. Measure the distribution of gaps between requests before deciding. For a service idle overnight and at weekends the saving is large. For a service with a steady trickle it is close to zero, and you are better off with a minimum instance count.

Why is my background job not running on Cloud Run or a similar platform?

Because CPU is throttled outside requests under request-time billing. A timer, a polling loop or a buffered telemetry flush assumes CPU is available between requests, and under that billing mode it effectively is not. Either switch to allocated-time billing for that service, or move the background work into a separate always-on service or a scheduled job. The failure is silent, which is what makes it expensive.

When do I actually need Kubernetes instead of one of these?

When you need something from the scheduler rather than from the service abstraction: per-node agents, custom controllers and operators, placement rules, injected sidecars by policy, stateful sets with stable identities, or privileged access to the host. If your deployment manifests contain none of those, a container platform will run the same workload with much less operational cost. Adopting a cluster for features you do not use is the more common mistake.

How do I reduce container cold start time?

In this order. Shrink the image, because image pull usually dominates and a multi-stage build that ships only the binary and its runtime dependencies is the single biggest win. Order your Dockerfile layers so the ones that change often are last, which improves cache hits. Then cut boot work: lazily initialise connection pools, do not run migrations at startup, and do not fetch remote configuration before serving the first request. Only after all of that is the platform’s own sandbox start time the limiting factor, and that is the one part you cannot change.