Rails hosting — 6 options compared

Rails has an unusually clear idea of how it wants to be deployed: a release phase for migrations, a process for jobs, credentials from a master key, and Active Storage pointed at a bucket. The right platform is the one that has all four without improvisation.

What is the best Rails hosting in 2026?

Rails wants four specific things: a release phase for migrations, a separate process for jobs, a master key it can read, and a bucket for Active Storage. Render at $7/month and Railway at $5/month plus usage are the smoothest managed starts and model all four. Kamal on a plain VPS is the cheapest credible production setup if you are happy owning the machine.

Granite — our own platform — is $9/month with $15 of usage credits, and puts the Postgres, the job runner and the bucket in one project, which is the version of this where nobody becomes a sysadmin.

Last updated 1 September 2026

Rails deployment stopped being hard some years ago, and the interesting question moved. It is no longer whether a host can run Ruby — they all can — but whether the platform models the things Rails assumes: somewhere to run migrations exactly once per deploy, a long-running process for jobs, and object storage that Active Storage can point at.

There is also a genuinely different answer available here that other stacks do not have. Kamal ships with Rails and deploys containers to plain servers you rent yourself, with zero-downtime rollouts and automatic TLS. It is a serious option, it is cheap, and it means the honest comparison is not just platform against platform but platform against a VPS you drive with a tool the framework already gives you.

The short version: Render and Railway are the smoothest managed starts, Kamal on a VPS is the cheapest credible production setup if you enjoy owning the machine, and Granite — our own platform — fits when you want the Postgres, the job runner and the bucket in one project without becoming a sysadmin.

How much does Rails hosting cost?

Sorted by entry price. Every provider here can build and run a Rails service; the columns are what separates them.
ProviderFrom /moFree tierManaged DBPersistent diskDeploy from
Fly.io~$2Postgres (unmanaged app)Dockerfile, buildpack
Railway$5yes ($1 credits)Git, Dockerfile, template
Render$7yes (spins down)Git, Dockerfile
Granite$9from AdvancedGit, Docker image
Koyeb$29limitedServerless PostgresGit, Dockerfile
Google Cloud Runusage-basedyes (monthly allowance)via Cloud SQLno (use GCS)Container image

Entry prices as published by each provider on 1 September 2026, sorted cheapest first. Usage, bandwidth and databases are billed on top almost everywhere — treat this column as a starting point, not a monthly bill.

PaaS, serverless or a plain VPS?

Pick the category before you pick the provider — it decides more than the logo does.

Kamal and a VPS deserve first mention here, because Rails ships the tool. Kamal builds your image, pushes it to servers you rent, does zero-downtime rollovers and handles TLS. On a €5 box that is a genuinely production-grade setup for less than any managed platform. What you keep is the responsibility: kernel updates, Postgres backups you have actually tested restoring, and being the person who gets up when the machine does not come back.

A managed platform buys exactly that responsibility off you. For Rails the valuable part is rarely the web tier — it is managed Postgres with backups, a place for jobs, and a release phase that runs migrations once instead of once per replica.

Serverless is the weakest fit of the three. Rails boots in seconds, so scale-to-zero puts that wait in front of a real visitor, and the framework expects a long-running process for jobs anyway. It can suit an internal tool that is idle most of the day; it is a poor default for anything public.

Where should Rails run?

You are happy owning a server, and price per gigabyte matters most

Kamal on a VPS

Zero-downtime deploys and TLS on a €5 box — you own backups and uptime.

Hetzner · DigitalOcean · Any VPS

You want managed Postgres, a job runner and storage without operating them

Managed platform

Web, worker and scheduler deploy together; migrations run in a release phase.

Granite · Render · Railway

Internal tool, idle most of the day, no user-facing latency budget

Serverless

Free while asleep, at the cost of a seconds-long wake-up.

Cloud Run · Koyeb

Rails is the one stack where a plain VPS is a first-class answer rather than a fallback — because the framework ships the deployment tool.

What does each platform actually give you?

Prices as published by each provider on the date above. Check them before you commit — they move.

Fly.io

Best for
Teams who want several regions and are content to run Postgres themselves.
Pricing
Pay as you go. The smallest shared-cpu-1x machine with 256 MB RAM works out at roughly $2.02/month, billed per second.
  • Multi-region deployment with Anycast routing, which suits an app with a geographically spread audience.
  • Takes your Dockerfile, and Rails 8 generates a production-ready one for you.
  • Per-second billing and cheap small machines.
  • Postgres is a Fly app you operate and back up — for Rails, where the database is the application, that is a real commitment rather than a detail.
  • The cheapest machines are too small for a useful Puma worker set.
  • No free tier for new organisations since October 2024.

Railway

Best for
Standing up Rails, Postgres and Redis together in one afternoon.
Pricing
Billing is per second of actual usage against a monthly minimum: $5 on Hobby and $20 on Pro, each including that much usage credit. The free plan is a 30-day trial with $5 of credits and $1 a month afterwards, capped at 1 vCPU and 0.5 GB per service. Pro includes unlimited workspace seats.
  • Templates cover the full Rails stack including Postgres and Redis for Sidekiq.
  • Services in a project reach each other privately, so the database needs no public endpoint.
  • A free plan and a 30-day trial for evaluation.
  • Usage-based billing on top of the base fee is hard to forecast for a memory-hungry stack.
  • Hobby seats one developer, so a two-person team starts at Pro's $20 monthly minimum instead of $5.

Render

Best for
A conventional Rails production setup with the least ceremony.
Pricing
Free web services are available but spin down after 15 minutes without traffic. The cheapest paid instance, Starter, is $7/month for 0.5 vCPU and 512 MB RAM.
  • Release commands are first-class, so db:migrate runs once per deploy in the right place.
  • Managed Postgres, Redis, background workers and cron jobs are all available in one account.
  • A real free tier for evaluating, with straightforward fixed pricing afterwards.
  • Free services spin down after 15 minutes, and a Rails cold start is slow enough to be noticed.
  • The 512 MB Starter tier fits a single modest Puma worker; a real app outgrows it quickly.

Granite

Best for
Running the web app, the job runner and the database as one project without operating any of the infrastructure.
Pricing
Hobby is $9/month and includes $15 of monthly usage credits. Advanced is $39/month with $50 of credits, Professional $149/month with $200. Every plan has unlimited workspace seats.
  • Managed Postgres and Valkey sit beside the app over internal DNS — Postgres for the app and Solid Queue, Valkey if you prefer Sidekiq.
  • S3-compatible storage with a CDN is included, which is where Active Storage attachments belong.
  • Web, worker and scheduler are three resources built from one image with different commands, so they share code, secrets and deploys.
  • Databases have no public endpoint at all, and workspace seats are unlimited on every plan.
  • No free tier — the cheapest way in is $9/month.
  • The Hobby plan caps at 1 GiB per service, and Puma with several workers wants more, so Rails pushes you to Advanced sooner than a lighter stack would.
  • Fewer regions than the hyperscalers, and no multi-region routing yet.

Koyeb

Best for
An internal or low-traffic Rails app where paying nothing while idle matters.
Pricing
Pro is $29/month plus compute and includes $10 of it; Scale is $299/month including $100. Serverless Postgres has a free tier of 5 hours a month at 0.25 vCPU, 1 GB RAM and 1 GB of storage, after which the smallest always-on instance is $29.76/month plus $0.50 per GB stored.
  • Managed Postgres available without leaving the platform.
  • Edge locations included rather than sold separately.
  • Scale-to-zero suits Rails badly: booting the app takes seconds and a real user waits through it.
  • The highest entry price of the managed options here.

Google Cloud Run

Best for
Stateless Rails services with bursty traffic, for teams already invested in GCP.
Pricing
No monthly fee. You pay per request and per resource-second, with a monthly free allowance. Cloud SQL and networking are billed separately.
  • Scales to zero and has effectively no ceiling.
  • Takes any container image, so the generated Rails Dockerfile applies unchanged.
  • No persistent disk, so Active Storage must use Cloud Storage from the outset.
  • Cold starts are seconds; setting min-instances to avoid them removes the saving that justified it.
  • Migrations need somewhere to run that is not a request handler, which means a separate job.

What does a Rails app need from a host?

The requirements that matter for Rails are different from the ones every generic hosting listicle repeats.
Rails-specific criteria
Rails is opinionated about deployment, which is helpful: it means there is a short list of things a platform either supports properly or does not.
A real release phase
db:migrate must run once per deploy, after the image is built and before the new version takes traffic. Putting it in the container start command means every replica races to migrate the same schema simultaneously. Look for a release command or pre-deploy hook and refuse to improvise around its absence.
RAILS_MASTER_KEY
Encrypted credentials are the Rails way to carry secrets, and the master key is the one secret that cannot live in the repository. It has to arrive as an environment variable, ideally from encrypted storage rather than a plaintext settings field.
A process for jobs
Rails 8 defaults to Solid Queue, which runs on your existing database and removes the need for Redis; Sidekiq remains the popular alternative and does need it. Either way, jobs run in a separate long-lived process, built from the same image as the web app so it can never drift out of sync.
Active Storage needs a bucket
Attachments written to local disk vanish on deploy and are invisible to a second instance. Configure the S3 service against object storage before you accept the first upload, not after the first support ticket.
Asset precompilation at build
assets:precompile belongs in the image build, not at boot. It needs the same environment as production, which occasionally means the master key must be available during the build too — a detail platforms handle with varying grace.
Memory per Puma worker
Each Puma worker is a full copy of the application; threads within it are cheap, processes are not. Memory therefore tracks worker count rather than request volume, so size the plan by workers and verify against real usage rather than provisioning optimistically.
$ docker images rails-app
REPOSITORY   TAG      SIZE
rails-app    naive    1.9GB
rails-app    slim     507MB
The same Rails app built two ways: once on the full ruby image with the toolchain left in place, once multi-stage with gems built separately and copied onto a slim base. Just under four times smaller. Note where it stops — 507 MB is more than Django's slim build and far more than a compiled binary, because the interpreter, the gems and their native extensions all have to ship. That floor is worth knowing before you compare per-gigabyte prices.

Where do background jobs and queue workers run?

In a second process, never inside Puma. Rails 8 ships Solid Queue, which keeps jobs in the Postgres you already have and needs no broker; Sidekiq remains the popular alternative and does want Redis or Valkey behind it. Either way the runner is a long-lived process started from the same image with a different command — bin/jobs or bundle exec sidekiq — so it cannot drift out of sync with the web code. Render and Railway call that a background worker; on Granite it is a worker resource in the same application, sharing its environment variables. A deploy replaces the container: Sidekiq takes SIGTERM, stops fetching, finishes what it holds and returns the rest to the queue. A crash is a restart and a retry, which is why every job has to be safe to run twice.

How do scheduled tasks and cron work?

Three mechanisms, one of which survives a second replica. The whenever gem writes a crontab, which assumes a machine you can write a crontab on — Kamal on a VPS, not a container platform. Solid Queue's recurring tasks live in config/recurring.yml and are dispatched through the database, so two workers do not double-fire them. Third is a platform cron: on Granite a cron-job resource runs bin/rails runner … on a cron expression as a single container — the type takes no replica count — with an explicit Forbid or Allow choice when the previous run is still going. Its output goes to the resource log: novps resources logs <id> --since 1h -f.

Is Postgres managed, and what about backups?

Managed on Render, Railway, Koyeb and Granite — pick the version and a node size and the credentials are generated for you. On Fly the Postgres is an app you run and get paged for. Granite backs databases up on a schedule into external storage and support can run point-in-time recovery for Postgres on request; the schedule is not published, so ask before you depend on an RPO. There is no public endpoint: the app reaches the database over internal DNS, you reach it with novps port-forward database <id> -l 5432. A pooler sits in front, which matters because Rails opens RAILS_MAX_THREADS connections per Puma worker — four workers at five threads is twenty from one service.

How do deploys and migrations work?

Push to the tracked branch and the platform builds and rolls out the image; point it at a Docker tag and it redeploys when the tag moves. Migrations are where they differ. Render and Railway give you a release command that runs bin/rails db:migrate once, after the build and before traffic. Granite has no release-phase hook: run it from the resource's Console tab, or forward the database port and run it from your machine, before the new image rolls. Putting db:migrate in the start command breaks everywhere — three replicas migrate the same schema at once. Rolling an image back does not roll the schema back, so write migrations the previous version can still read.

What does it actually cost per month?

One web service, one job runner, one small Postgres, as of 1 September 2026. Render: $7 for the Starter web service, $7 for the worker, $6 for a 256 MB Postgres — $20, plus $10 for a 256 MB Key Value instance if you run Sidekiq rather than Solid Queue. Fly.io: two shared-cpu-1x machines at 512 MB, $3.32 each, and a Postgres you operate on a third — cheapest on paper, and you own the restores. Railway bills per second against a $5 monthly minimum on Hobby. Granite is $9 on Hobby with $15 of credits the app, the worker and the database all draw from, capped at 1 vCPU, 1 GiB and one replica per service — a real Puma set beside Sidekiq lands on Advanced at $39.

So which should you pick?

You enjoy owning the machine and want the lowest bill. Kamal on a VPS. It is the setup Rails itself is designed around, and it is hard to beat on price. Budget an evening a month, and test your Postgres restore before you need it.

A conventional production app, least ceremony. Render. Release commands, managed Postgres and workers are all there and behave the way the Rails guides assume.

Fastest path to a running stack. Railway, whose templates assemble Rails, Postgres and Redis for you.

Web, jobs, database and attachments as one project. This is where we would argue for Granite. Postgres and Valkey run beside the app with no public endpoint, S3-compatible storage with a CDN gives Active Storage a home, and web, worker and scheduler are three resources from one image that deploy together. From $9/month, though a real Puma worker set will want the Advanced plan.

Running services in other languages beside it? The Go and Django comparisons cover the same platforms with different conclusions, and the app platform page covers workers and cron jobs in detail.

Hosting for other stacks

Go hosting

Six ways to run a Go binary, from a $2 machine to scale-to-zero — and why Go stays cheap longer.

Django hosting

Seven options weighed on the things Django actually needs: media storage, a real Postgres, Celery workers and enough memory for gunicorn.

Next.js hosting

Vercel and six alternatives, weighed on the things that actually break when you self-host: ISR across replicas, image optimization and build-time env vars.

Node.js hosting

Six ways to run an Express, NestJS or Fastify service — weighed on the event loop, the connection pool, and what a long-lived process costs while it waits.

Laravel hosting

Laravel Cloud and six alternatives, weighed on queue workers, the scheduler, writable storage and the caches you must rebuild on every deploy.

Python hosting

Seven platforms for Django, Flask, FastAPI or a script with no HTTP port at all — and how to tell which of those you are actually deploying.

FastAPI hosting

Six platforms weighed on what an ASGI service actually needs: worker processes, connections that stay open, and a database pool that does not multiply out of control.

Flask hosting

Seven options for the framework that ships no opinions — weighed on the WSGI server you have to bring, the session key you must keep stable, and the extensions that decide the rest.

Symfony hosting

Six platforms weighed on the things Symfony assumes: a warmed cache built at build time, Messenger workers that restart on deploy, and Doctrine migrations that run exactly once.

Remix hosting

Seven platforms for a framework that renders on every request — weighed on streaming, adapters, and how far the loaders sit from the database.

Spring Boot hosting

Six platforms weighed on what the JVM actually asks for: memory it is allowed to use, a container that knows its own limits, and a start-up you can afford to repeat.

Docker hosting

Six places to run a container image, compared on what actually bites: architecture mismatches, registry access, signal handling and the volume you assumed would still be there.

Static site hosting

Five ways to serve HTML that is already written — and an honest note about which of them we are not the right answer for.

Rails hosting questions

More questions? Email us at support@granite.so

Be first in line for updates
and special pricing
Get early access to new features and exclusive discounts delivered straight to your inbox