"No cold starts" is usually sold as a performance feature. It is really a correctness feature. A websocket server that gets stopped drops its connections. A queue worker that sleeps stops consuming. An interval inside your app never fires. An inference container reloads a model that was already in memory. None of those are slow — they are broken, and they break quietly, which is worse.
So the ordering below is by how reliably a process stays resident, and the price of the cheapest plan where that is true. Platforms that stop containers when idle are not worse products; they are built for workloads with a different duty cycle, and the last section says which.
Hostim
Never sleeps · flat priceContainers are long-lived processes with no idle timeout and no scale-to-zero anywhere in the product, including on the cheapest plan. Websockets, in-memory caches, cron-style intervals, connection pools and loaded model weights all survive between requests because the process is never replaced for being quiet.
| Idle behaviour | None. The process keeps running regardless of request volume |
|---|---|
| Scale to zero | Not offered on any plan |
| Entry price for an always-on app | €2.50/month for 1 vCPU and 1 GB (plan sa-1-1) |
| Billing while idle | Same flat monthly price — idling costs exactly what serving costs |
| Background workers | A second app from the same image with a different start command |
| Persistent volumes | Yes, reattached across deploys and restarts |
Where it is strong
- No idle timeout to work around, so there is nothing to keep warm with a ping job.
- The cheapest always-on plan in this list, and it includes a permanently free managed database.
- Model weights load once from a mounted volume and stay in memory across requests.
Where it falls short
- You pay for the container while it is idle, which is the wrong model for a staging environment used one hour a week.
- One region, in Falkenstein, Germany — roughly 95 ms from the US East Coast.
- CPU only. Good for embeddings, classical ML and smaller models; GPU is not available in any region.
- Hostim.dev price list — Hostim.dev (checked 2026-08-06)
- Pricing model — plan-based billing, no metering — Hostim.dev docs (checked 2026-08-06)
Sevalla
Stays running · usage-meteredPods run continuously — there is no sleep or hibernation mode in the product — and they are billed by the second while they do. A Kinsta product with the widest location list here, at the highest price per unit of CPU and memory.
| Idle behaviour | No documented sleep or hibernation mode |
|---|---|
| Scale to zero | Not documented |
| Entry price for an always-on app | S1 $10/month for 0.5 CPU and 1 GB with a custom domain; the $5 H1 pod has no custom domain |
| Billing while idle | Metered by the second, so an idle pod still accrues its full rate |
| Outbound traffic | $0.10/GB, plus build time at $0.02/minute |
| Persistent volumes | Yes |
Where it is strong
- Twenty-five data centre locations, including Ashburn, Los Angeles, Montréal, Tokyo and Sydney.
- Deploys from a Dockerfile, buildpacks or your own image.
- Kinsta behind it, which is more operating history than most platforms this size.
Where it falls short
- Roughly ten times the price of the cheapest option here at the same CPU and memory — S4 (4 CPU, 8 GB) is $160/month against €13.50.
- Per-second billing with no sleep means you get the cost profile of metering without the saving that idling normally buys.
- Egress and build minutes are separate metered lines on top of the pod.
- Application hosting — Sevalla (checked 2026-08-07)
- Application hosting pricing — Sevalla (checked 2026-08-07)
- Application pricing — usage-based billing — Sevalla docs (checked 2026-08-07)
DigitalOcean App Platform
Stays running · fixed containerPaid service containers run continuously at a fixed monthly price, which makes this one of the more straightforward always-on options. The variability sits in the database and the bandwidth rather than in whether your process is alive.
| Idle behaviour | Paid service containers run continuously |
|---|---|
| Scale to zero | Not part of the service container model |
| Entry price for an always-on app | From $5/month per container |
| Billing while idle | Fixed monthly container price, unchanged by request volume |
| Outbound traffic | Included allowance, then per-GB overage |
| Database | Managed PostgreSQL from $15/month, no free tier |
Where it is strong
- Fixed container price is easy to plan around for a service that must stay up.
- A full cloud around the app — object storage, load balancers, managed Kubernetes.
- Wide region list, including North America and Asia.
Where it falls short
- The managed database costs three times the container it serves.
- Bandwidth overage remains a usage line even though compute does not.
- US company, so EU-region data stays reachable under the US CLOUD Act.
- App Platform pricing — DigitalOcean (checked 2026-08-06)
- Managed databases pricing — DigitalOcean (checked 2026-08-06)
Railway
Stays running · fully meteredServices run continuously and are billed per second while they do. Nothing sleeps by default, which is what you want for a worker or a websocket server, and it also means an always-on service pays the full metered rate for every hour of the month.
| Idle behaviour | Services keep running; no default sleep |
|---|---|
| Scale to zero | Not the default model |
| Entry price for an always-on app | Hobby $5/month including $5 of credit; Pro $20/month per workspace including $20 of credit |
| Billing while idle | $20 per vCPU-month and $10 per GB of RAM per month, accrued per second whether busy or not |
| Outbound traffic | $0.05/GB |
| Volumes | $0.15/GB-month |
Where it is strong
- Per-second billing scales down properly for spiky or part-time workloads.
- Templates and one-click services make the first hour faster than anywhere else here.
- The deploy experience is the benchmark others are measured against.
Where it falls short
- An always-on service is the worst case for this billing model — full rate, every hour, all month.
- No free tier, only a one-time $5 credit.
- The plan fee is charged before any usage, so there is a floor as well as an open ceiling.
- Railway pricing — Railway (checked 2026-08-06)
- Usage-based pricing: why Railway and Render bills creep up — Hostim.dev blog (checked 2026-08-06)
Render
Paid stays up · free tier sleepsPaid instances stay running; free web services spin down after about 15 minutes of inactivity and wake on the next request. That split is the whole story here — Render is always-on the moment you pay for it, and explicitly not always-on before that.
| Idle behaviour | Free web services spin down after about 15 minutes idle and wake on request; paid instances stay up |
|---|---|
| Scale to zero | On the free tier, by design |
| Entry price for an always-on app | Starter web service $7/month for 0.5 CPU and 512 MB |
| Billing while idle | Fixed instance price; egress and storage metered separately |
| Outbound traffic | 5 GB/month included on Hobby, then $0.15/GB |
| Database | Basic-256mb $6/month; the free database expires after 30 days |
Where it is strong
- The free tier is genuinely useful for prototypes if cold starts are acceptable.
- Cron jobs, preview environments and autoscaling in the same product.
- Instance pricing does not track request volume.
Where it falls short
- The free tier sleeping makes it unusable for a bot, a worker or anything holding state.
- Egress at $0.15/GB after 5 GB is the most expensive traffic rate in this list.
- Database failover starts at Pro-4gb, $55/month.
- Render pricing — Render (checked 2026-08-06)
- Render vs Railway vs Fly.io pricing — Hostim.dev blog, June 2026 (checked 2026-08-06)
Fly.io
Stops when idle by defaultMachines stop when idle and then cost only their disk. That is the point of the product and it is excellent for intermittent work, but it means a resident process is something you configure and pay for rather than the default you get.
| Idle behaviour | Machines stop when idle and restart on demand |
|---|---|
| Scale to zero | Yes — the default behaviour |
| Entry price for an always-on app | About $2.32/month for a shared-cpu-1x machine with 256 MB left running; about $6.79/month at 1 GB (Fly's own examples, sjc region) |
| Billing while idle | Only the disk, if the machine has stopped |
| Outbound traffic | $0.02/GB in the EU and US |
| Database | Managed Postgres Basic (shared-2x, 1 GB) $38/month plus $0.28 per provisioned GB |
Where it is strong
- The cheapest way here to run something that is idle most of the time.
- Fine-grained region placement across a large location list.
- Egress at $0.02/GB is the cheapest traffic rate in this comparison.
Where it falls short
- A stopped machine has lost whatever it held in memory, so in-process caches and warm model weights do not survive an idle period.
- Managed Postgres at $38/month for 1 GB of RAM ends the cheap story at the database.
- No free allowance — billing starts with the first machine.
- Fly.io pricing — Fly.io (checked 2026-08-06)
Heroku
Eco dynos sleep after 30 minutesThe cheapest Heroku tier sleeps, which disqualifies it for the workloads this page is about. Staying awake means moving up the dyno ladder, and the capabilities that keep a stateful app working tend to arrive as paid add-ons rather than as part of the dyno.
| Idle behaviour | Eco dynos sleep after 30 minutes of inactivity |
|---|---|
| Scale to zero | Effectively yes on Eco, through sleeping |
| Entry price for an always-on app | Above the Eco tier — Eco is $5/month for 1,000 shared compute hours and sleeps |
| Billing while idle | Fixed dyno price, plus each add-on subscription |
| Database | Postgres Essential-0 from $5/month; free plans removed on 28 November 2022 |
| Infrastructure | Runs on AWS; EU region is Ireland |
Where it is strong
- The add-on marketplace and buildpacks remain the fastest path for a team that will not write a Dockerfile.
- Fifteen years of documentation and answered questions.
- The dyno price itself does not move with traffic.
Where it falls short
- Eco dynos sleeping after 30 minutes rules out bots, workers, websockets and anything holding state.
- Add-ons turn one predictable line into several.
- No free tier since November 2022.
- Heroku pricing — Heroku (checked 2026-08-06)
- Removal of Heroku free product plans FAQ — Heroku (checked 2026-08-06)
How this list was made
Idle behaviour and prices were read from each vendor's own documentation and pricing pages on 2026-08-06. Where a vendor does not document a sleep or scale-to-zero mode, that is stated as "not documented" rather than asserted as "never happens".
Every entry lists where the platform falls short, ours included. The honest cost of always-on hosting is that you pay for the container while it does nothing, and that is written into our own entry rather than left out of it.
Left out: serverless function platforms, because a function is not a resident process and comparing it here would only restate its definition; and self-managed Docker on a VPS, where the process stays up because you are the one keeping it up. Both are covered from other angles in the alternatives hub.
Explore Other Alternatives
Compare Several Platforms at Once
Frequently asked questions
What is always-on container hosting?
Hosting where your process keeps running between requests instead of being stopped when traffic goes quiet. It matters when the process holds something: a websocket connection, an in-memory cache, a scheduled interval, a database connection pool, or model weights loaded into RAM. On a platform that sleeps or scales to zero, all of that is discarded when the container stops and rebuilt on the next request, which is what a cold start actually is.
Which platforms keep a container running and which stop it?
Hostim, Sevalla, DigitalOcean App Platform and Railway keep the process running by default. Render keeps paid instances up but spins free web services down after about 15 minutes of inactivity. Fly.io stops machines when idle by default — that is the design, not a limitation. Heroku Eco dynos sleep after 30 minutes. Serverless function platforms are a different shape entirely and are not on this list, because a function is not a resident process at all.
Why do cold starts break machine learning inference?
Because the expensive part is loading the model, not answering the request. A resident container loads weights once at startup from a mounted volume and keeps them in memory for every request after that. A container that stopped while idle has to reload them, so the first request after a quiet period pays the full load time. Function timeouts compound it by truncating long generations, and per-request billing penalises exactly the streaming behaviour you want. A long-lived container fixes all three by being unremarkable.
Do I need always-on hosting for background jobs and cron?
For a queue worker, yes — it has to be listening when the job arrives, and a worker that sleeps is a queue that backs up. For scheduled work, it depends: some platforms offer a managed cron feature that starts a container on a schedule, which is a reasonable fit for a nightly batch. If the schedule is inside your app as a timer or an interval, the process has to stay resident for it to fire, so a sleeping platform will silently skip it.
What is the cheapest always-on container?
Hostim at €2.50/month for 1 vCPU and 1 GB RAM, with no idle timeout and a permanently free managed database next to it. Render's cheapest always-on option is the $7/month Starter web service, since the free tier sleeps. Sevalla's cheapest pod that can serve a custom domain is $10/month. Fly.io can be cheaper than any of these for something genuinely intermittent, at roughly $2.32/month for a small machine left running — but its normal mode is to stop the machine, which is the opposite of what this list is about.
Is paying for an idle container wasteful?
Sometimes, and it is worth being honest about when. A staging environment used one hour a week is cheaper on a platform that stops the machine, and Fly.io or Railway will serve that better. Reserved always-on pricing wins when the container is doing something most of the time, or when it must be able to respond instantly without a warm-up — an API, a bot, a worker, a websocket server, an inference service. Pick the model that matches the duty cycle, not the one with the lower headline number.
Get Started with Hostim.dev
Deploy any Docker image, Git repo, or template instantly. Explore in a free 5-day trial project – no credit card required.