Fourteen Criteria, Ten Platforms, Three Bills: When Railway and Render Stop Being Cheap

A solo developer evaluated ten hosting platforms against fourteen weighted criteria and priced the same app three times. The numbers came back $0-10 for a POC, $40-60 for an MVP, and $200-500 for growth — on every PaaS — except the one that never charges per gigabyte.

In July 2026, Toni Melisma's open-source project Selko — an AI assistant that turns emails into calendar events via FastAPI + Supabase + Gemini — shipped a hosting evaluation that most side projects never bother to write down. The commit message is unusually specific: ten platforms (Fly.io, Railway, Render, Cloud Run, AWS, Azure, DigitalOcean, Heroku, Vercel/Netlify, VPS), fourteen weighted criteria (developer experience, cost, FastAPI support, observability, and more), plus a managed-Redis comparison and a rationale for why the project landed on Render Starter at $7 per month for its MVP.

The evaluation file itself no longer lives on main — recent checkouts of tonimelisma/selko carry the decision in PRD_ARCH.md and CHANGELOG.md rather than a standalone HOSTING_EVALUATION.md — but the three cost projections are still explicit: a local CLI + Supabase POC at roughly $0, an always-on MVP at $40-60, and a scaled deployment at $200-500. This post reconstructs the evaluation, verifies every live 2026 price behind it, and runs the break-even math the original was built to answer: at what traffic does Railway or Render stop being cheap?

The short answer is in the table below. The rest is how Selko got there.

The answer up front: three stages, ten bills​

We repriced the same Selko-shaped workload at each stage using live August 2026 pricing (Hetzner post-June-15, Render post-April-23, Fly.io per-second). Every total includes compute, outbound bandwidth, storage/snapshots, managed Postgres, and platform fees — the whole invoice.

Workload shapes:

• POC: Local CLI + Supabase free tier, no always-on server, no Redis. Traffic ~0, storage <1 GB.
• MVP: One always-on FastAPI API (0.5-1 vCPU, 512 MB-1 GB), Supabase Postgres, polling every 60s, dashboard. ~50k requests/mo, ~20 GB egress, 5 GB volume.
• Growth: Three instances across two regions, workers for LLM extraction, ~500k-1M requests/mo, ~500 GB egress, 50 GB volume with 7-day snapshots.

The shape is immediate: at POC every platform clusters at $0-10 — the decision is developer experience. At MVP the $40-60 band is real but narrow; the dominant cost is the first always-on box plus the first managed Postgres, not bandwidth. At Growth the band widens to $90-500 because 500 GB of egress costs $71 on Render, $25 on Railway, $10 on Fly.io, and $0 on Hetzner.

Two 2026 moves sharpen this: Hetzner raised CPX/CCX 113-209% on June 15, 2026 (CX22→CX23, CPX11→CPX22 generational rename), and Render force-migrates legacy workspaces to 5 GB Hobby / 25 GB Pro + $0.15/GB on August 1, 2026. Both are priced in above.

The fourteen criteria: what a solo dev actually weighted​

Selko's commit describes fourteen weighted criteria. PRD_ARCH.md and supporting docs name the decisive ones; the rest follow from the rejected alternatives. Grouped by weight:

P0 — kills the option if it fails:

1. FastAPI / Python async support — The backend is async-native asyncio + Pydantic with concurrent Gmail, Gemini, and Supabase I/O. Any platform that forces a synchronous buildpack or cannot keep an event loop hot was rejected. Cloud Run's "scale to zero kills APScheduler" is why Render's always-on won.
2. Managed Postgres with RLS — Supabase Postgres with Row Level Security is the only database. Platforms without a first-class managed Postgres were penalized.
3. Background work without Redis — The job system is status-based Postgres polling (FOR UPDATE SKIP LOCKED), not a separate Redis queue — to avoid $10 for Redis plus a second Render service ($7 API + $7 worker = $14). Platforms that required Redis were marked up.
4. Cost predictability at MVP — Flat $7 on Render Starter was valued over per-second metering for a solo dev who needs to know the bill is still $7 on a quiet week.

P1 — strongly weighted:

5. Developer experience (git push → live) — "Git push, no IAM/Kubernetes/VPS config" is the verbatim Render rationale. Time to first cron matters more than benchmark throughput.
6. Observability — Every LLM call is logged with tokens, latency, and estimated cost (llm_logging.py, llm_usage_log). Platforms with weak log retention were downgraded.
7. Always-on scheduling — Email discovery ticks every 60s via email_sync_state leases. Scale-to-zero without an always-on option (or a required external pinger like Cloud Scheduler) was treated as complexity, not savings.
8. Managed Redis option — Not needed for POC/MVP, but growth presumes Upstash/Redis Cloud or Postgres-backed queues. Compared separately.
9. Custom domains + TLS — Every platform handles this, but friction differs (Vercel automatic, Fly/Caddy, VPS manual).
10. Region and data residency — Hetzner (DE/FI/US/SG) vs. Fly.io (30+ regions) vs. hyperscalers. Material for EU workloads, not latency-sensitive at MVP.

P2 — tie-breakers:

11. Vendor lock-in / portability — Render's Docker + Supabase is more portable than Vercel's framework coupling; VPS is maximally portable but maximally operational.
12. Uptime and SLA — Render Starter has no formal SLA; Hetzner and hyperscalers do. Selko accepted the tradeoff for velocity.
13. Documentation and community — FastAPI + Supabase + Render has a well-trodden path; niche providers were penalized if their Postgres story was thin.
14. Ecosystem (storage, auth, cron) — Supabase Storage + Auth with JWT/RLS integration counted as a combined win; platforms requiring separate S3 + Auth0 + Postgres assembly were marked down.

Render won the POC on criteria 1, 3, 4, and 5 together: async-native, no Redis, $7 flat, git push. Not performance. The cheapest way to keep a Python scheduler alive without becoming a sysadmin.

The ten platforms in one line each​

This is the Selko registry as named in the commit, with the live 2026 verdict:

• Fly.io — Best per-second value if you accept the ops surface. $2.02 per 256 MB shared-cpu, $0.02/GB egress (cheapest metered), auto-stop saves at POC, but you own the Postgres and volume snapshots.
• Railway — "Git push like Render, billed like AWS." $5 credit then $20/vCPU + $10/GB RAM + $0.05/GB egress per second. Cheaper than Render at Growth only if egress stays mid-range.
• Render — The Selko pick. $7 Starter (0.5 CPU, no sleep), $25 Standard, 5 GB/25 GB/1 TB included then $0.15/GB. You pay the egress tax at Growth, but you never debug a machine.
• Cloud Run — Scale-to-zero champion. Free tier covers POC outright; $0.000024/vCPU-second is unbeatable if idle. Loses to Render only because APScheduler needs a $25 always-on instance or Cloud Scheduler + IAM.
• AWS Fargate — The "if you already live on AWS" answer. Per-second plus $16 NAT + $22 ALB makes the MVP heavier than it looks. Competitive at Growth but never simple.
• Azure Container Apps — Underrated at MVP. Consumption 180k vCPU-seconds free, Dedicated profile at Growth is predictable.
• DigitalOcean App Platform — Quiet value pick. Basic $5 + $15 Postgres + generous 1 TB transfer before $0.02/GB.
• Heroku — Frozen incumbent. No free tier since 2022, Eco $7 (sleeps) → Standard $50, sustaining mode since Feb 6, 2026 (stability/security only). Flat included egress is still its best trait; the lack of roadmap is why Selko rejected it.
• Vercel / Netlify — Framework PaaS, not API PaaS for this workload. Hobby 100 GB / Pro 1 TB then $0.15/GB (Vercel) makes no sense for a polling Python API with workers — included as the baseline a frontend team would already know.
• VPS / Hetzner — The control branch. CX23 €3.99 or CPX22 €7.99 post-hike, 20 TB included, self-hosted Postgres at $0. Cheapest after POC, most operational — the comparison bex exists to compress.

Selko deliberately avoids Redis until growth forces it, saving the $10 Redis line plus the second service fee that would double Render from $7 to $14 at MVP — a small number that matters when the whole band is $40-60.

When each stage breaks and where flat beats metered​

POC ($0-10): every platform looks free — and that is the point​

POC is a local CLI plus Supabase free tier. No always-on server, no Redis. Gmail polling uses history.list at 2 quota units (vs. 5 for messages.list), Gemini calls are pay-per-token at cents. Fly.io can run auto-stopped at ~$0, Vercel Hobby stays within 100 GB, Render sleeps fine when the runner is a CLI. Hetzner is not worth provisioning.

Cost has no variance to discriminate on, so the fourteen criteria do the ranking. The question is not "what is cheapest?" but "what keeps a Python scheduler alive for $7 without splitting services?" Render's answer — one always-on service, no Redis — beats Cloud Run's "$25 always-on or add Cloud Scheduler + IAM" and Railway's "you think in GB-hours" for a solo dev optimizing for velocity over unit price.

MVP ($40-60): the platform fee appears​

MVP adds one never-sleeps FastAPI API and one small managed Postgres. At 20 GB egress the bill is dominated by those two lines:

• Compute: Render $7-25 vs. Railway ~$18 vs. Fly ~$6 (2× 256 MB) vs. Hetzner CX23 ~$4.30 vs. AWS Fargate ~$22 + NAT $16.
• Postgres: Supabase Pro $25, Render $7-20, Fly volume $6, RDS micro ~$15-20, self-hosted $0.
• Egress (20 GB): Railway $1.00, Render ~$0-2.25, Fly $0.40, Cloud Run $2.40, AWS $1.80, Hetzner $0.
• Storage: Negligible at 5 GB across all.

Every metered PaaS lands at $35-70 here before seat fees — which is why Selko's $40-60 projection is a measurement, not marketing. Hetzner/self-hosted at $7-15 is the only breakout because the database is not a separate SKU. Splitting API and worker into two Render services would push this from $7 to $14 plus $10 Redis, which is why Selko kept the monolith until ~10,000 users.

Growth ($200-500): egress becomes the bill​

Tripling compute from one to three instances roughly triples the compute line everywhere, but 500 GB of egress multiplies the egress line by 25× over MVP at different rates:

• Railway 500 × $0.05 = $25
• Render (500 − 25) × $0.15 = $71.25
• Fly.io 500 × $0.02 = $10 (NA/EU)
• Cloud Run 500 × $0.12 = $60
• AWS 500 × $0.09 = $45 (+ NAT/ALB at $38 fixed)
• Azure 500 × $0.087 = $43.50
• DigitalOcean 500 × $0.02 = $10 (often $0 within 1 TB pool)
• Hetzner $0 — 20 TB included per box

At 500 GB, Render egress is 7× Fly.io and infinitely × Hetzner. At 2 TB, Render egress alone is ~$296 — more than the entire Hetzner growth bill of $25-55. Managed services widen the gap further: Cloud SQL $50-80, RDS $80, NAT $16, ALB $18-35 appear at growth even before egress multiplies.

The break-even: how many gigabytes before flat wins​

Leaving a metered PaaS for flat hardware is a threshold on gigabytes:

break_even_GB = flat_box_cost ÷ egress_rate

For precision, include the compute delta:

leave_when: (metered_compute + egress×rate + managed_db) > (flat_compute + self_hosted_db_ops)

Worked thresholds (flat = Hetzner CX23 ~$4.30, compute delta ignored):

A 100 MB image-heavy page served to 300 users a day clears 29 GB a month — enough to pay for the Hetzner box that would have carried it for free. For Fly.io the crossing takes ~215 GB, which is why its value holds longer.

With the Render Standard ($25) vs. Hetzner CX23 ($4.30) compute delta of $20.70 included, the fixed-cost gap between a 3× Render growth stack ($105 before egress) and a 3× Hetzner stack ($13) is ~$92, paying for 613 GB of Render egress at $0.15 before flat even needs to justify itself. At growth, flat is not a small optimization — it is 4× to 15× cheaper at 500 GB in every recompute above, widening with bytes because only one side has a meter.

What to pick and when to leave​

At POC ($0-10): Pick on DX, not dollars. Selko picked Render for the smallest ops surface that keeps a Python scheduler alive. If you are Next.js-heavy, Vercel Hobby within 100 GB is equivalent. For maximal scale-to-zero, Cloud Run's free tier covers POC outright. Do not self-host at POC.

At MVP ($40-60): You are buying one always-on box and one managed Postgres. Any PaaS lands here; switching for cost is premature. If egress already exceeds ~30-80 GB, price the next stage before you lock in.

Approaching growth ($200-500): Track three numbers monthly: egress GB, compute GB-hours, and fixed DB/NAT/ALB lines. Dual-price every month's bill against one Hetzner CPX32 (~€12-16) as the null hypothesis. Selko's crossing starts at ~29 GB on Render, ~86 GB on Railway, ~215 GB on Fly.io.

At growth: The flat fleet is 4-15× cheaper at 500 GB and the gap scales with bytes. The ops cost to earn that saving — Postgres, Caddy/Traefik, snapshots — is real; a platform that compresses it matters more than the raw price list.

Selko's evaluation matters not because it anointed a winner — Render at $7 for minimal ops — but because it priced the crossing in fourteen trade-offs and three stages. Hosting comparisons usually quote a sticker without the line that scales: at POC it is all stickers, at MVP it is the first always-on box plus the first managed database, at growth it is egress. Three bills, ten platforms, one question: how many gigabytes before the per-GB meter costs more than the box that never had one.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. The same app that costs $200-500 on metered egress runs on a flat Hetzner fleet for $25-55. Star the repo on GitHub or ship your first service today.

Sources​

• Selko project (tonimelisma/selko): PRD_ARCH.md deployment strategy (Render Starter $7, Supabase, rejected Cloud Run always-on ~$25 and separate worker + Redis $14), CLAUDE.md, and the evaluation commit message "10 platforms: Fly.io, Railway, Render, Cloud Run, AWS, Azure, DigitalOcean, Heroku, Vercel/Netlify, VPS — 14 weighted criteria" via GitHub search. No HOSTING_EVALUATION.md on current main; reconstructed from PRD_ARCH.md and CHANGELOG.md.
• Render: workspace plans April 23, 2026 (Hobby 5 GB / Pro 25 GB / Scale 1 TB, then $0.15/GB; legacy force-migrate Aug 1, 2026) — render.com/changelog/updated-plans-for-render-workspaces.
• Railway: $20/vCPU + $10/GB RAM + $0.05/GB egress, per-second — docs.railway.com/pricing/plans.
• Fly.io: shared-cpu-1x 256 MB $0.00000078/s ($2.02/mo), volume $0.15/GB-month, egress $0.02/GB NA/EU — fly.io/docs/about/pricing.
• Cloud Run: $0.000024/vCPU-sec, 180k free, egress $0.12/GB — cloud.google.com/run/pricing.
• AWS Fargate + NAT/ALB + egress $0.09/GB — aws.amazon.com/fargate/pricing.
• Azure Container Apps: Consumption vs. Dedicated, egress $0.087/GB — azure.microsoft.com/pricing/details/container-apps.
• DigitalOcean App Platform + Postgres, egress $0.02/GB — digitalocean.com/pricing.
• Heroku sustaining mode Feb 6, 2026 — heroku.com/blog/sustaining-engineering; pricing Eco $7 / Basic $25 / Standard $50.
• Vercel Hobby 100 GB / Pro 1 TB then $0.15/GB ($40/100 GB overage); Netlify $55/100 GB — vercel.com/pricing.
• Hetzner Cloud post-June-15-2026 rates (CX/CAX +30-40%, CPX/CCX +113-209%, CX22→CX23 rename) — docs.hetzner.com/general/infrastructure-and-availability/price-adjustment/ and api.hetzner.cloud/v1/server_types.