The Fastest Way to Deploy a Ruby on Rails App in 2026

✨ Summarize this content with AI

Deploying a Ruby on Rails app to production is one of those tasks that looks straightforward on the surface - until you actually try it.

Unlike a static site or a simple Node.js server, a Rails app arriving in production has real requirements. You need a production-grade web server (Puma), a PostgreSQL database wired via DATABASE_URL, migrations that run automatically before the app starts, assets compiled before the first request hits, a valid SECRET_KEY_BASE, HTTPS enforced, and - if your app uses background jobs - Sidekiq running as a separate process. Miss any one of these and your app either won’t start or will behave incorrectly in ways that are painful to debug.

For years, Heroku was the default answer for Rails developers who didn’t want to handle all of this manually. It understood the Rails conventions, ran buildpacks, and made the Procfile + release phase pattern familiar to an entire generation of developers. Then it removed its free tier in 2022 and pricing shifted enough that many teams started looking elsewhere.

Today there are several solid options depending on how much control you want versus how much configuration you’re willing to manage. This guide covers how to deploy a Ruby on Rails app in 2026 across different approaches - from manual VPS setup to modern PaaS platforms - with a step-by-step walkthrough for each.

What this guide covers:

What you need before deploying a Rails app to production
Step-by-step deployment on Kuberns (AI-automated, no Procfile)
How to handle Rails-specific requirements: PostgreSQL, Sidekiq, Action Cable, Active Storage
A platform comparison table across Heroku, Render, Railway, Fly.io, and Kuberns
The most common Rails deployment errors and how to fix them

What a Production Rails Deployment Actually Needs

Rails is a full-stack, opinionated framework. That’s its strength. But it also means production has non-negotiable requirements that you can’t skip.

Here’s what every production Rails deployment needs before it can serve real traffic:

Puma web server - Rails’ built-in development server (rails server) is single-threaded and not safe for production. Puma needs to be configured with the right number of workers and threads for your server’s memory.

rails db:migrate - Schema changes don’t apply themselves. This must run before the app starts on every deploy. Run it after boot and you get errors. Forget it entirely and the app crashes on the first database query.

rails assets:precompile - In production, Rails doesn’t serve assets on the fly. CSS, JavaScript and images must be compiled to the public/assets directory before the first request arrives. Skip this and your app loads without styles.

SECRET_KEY_BASE - Rails will not start in production without this environment variable. It must be long, random, and kept secret. Generate one with rails secret.

PostgreSQL - SQLite is not suitable for production Rails apps. You need a PostgreSQL database with database.yml reading the connection string from DATABASE_URL.

RAILS_SERVE_STATIC_FILES - By default, Rails in production doesn’t serve static files, expecting a reverse proxy like Nginx to handle that. If you’re not setting up Nginx, this env var must be set to true.

SSL - Every production app needs HTTPS. On a VPS, that means Certbot with a cron for certificate renewal. On modern PaaS platforms, it’s automatic.

Sidekiq (if using background jobs) - Sidekiq must run as a separate process alongside the Puma web server. It needs its own Redis connection and must be restarted independently.

On a manual VPS, handling all of this from scratch takes 30 to 40 steps. On Heroku, you needed a Procfile, release phase for migrations, a buildpack for assets, and a separate paid worker dyno for Sidekiq. Render and Railway still require Procfiles and manual build commands.

For a broader comparison of platforms that support Rails apps, see our guide to the best Heroku alternatives for Rails apps.

Prerequisites Before You Deploy Your Rails App

Before deploying, make sure these four things are in order.

1. Gemfile with production dependencies

Your Gemfile must include these gems for a production Rails deployment:

gem 'puma', '~> 6.0'        # Production web server
gem 'pg', '~> 1.1'          # PostgreSQL adapter
gem 'bootsnap', require: false  # Faster boot times
gem 'rack-timeout'           # Prevent hung requests in production

Run bundle install locally and commit your updated Gemfile.lock before pushing to GitHub.

2. database.yml configured for DATABASE_URL

Your config/database.yml production section should read from the environment:

production:
  adapter: postgresql
  encoding: unicode
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  url: <%= ENV['DATABASE_URL'] %>

This is how Kuberns (and every modern platform) connects your app to the database without hardcoding credentials.

3. Production environment settings

In config/environments/production.rb, ensure these are set:

config.force_ssl = true
config.log_level = :info
config.public_file_server.enabled = ENV['RAILS_SERVE_STATIC_FILES'].present?

4. Environment variables ready

Collect these before deploying. You will paste them into Kuberns:

Variable	Value
`DATABASE_URL`	Your PostgreSQL connection string
`SECRET_KEY_BASE`	Run `rails secret` to generate
`RAILS_ENV`	`production`
`RAILS_SERVE_STATIC_FILES`	`true`
`RAILS_LOG_TO_STDOUT`	`true`
`WEB_CONCURRENCY`	`2` (adjust based on plan)

On a VPS, you would also install and configure Nginx as a reverse proxy, write a Puma systemd service file, set up Certbot for SSL with a cron for renewal, create a PostgreSQL user and database, configure pg_hba.conf, and manually run db:migrate and assets:precompile after every single deploy. On Kuberns, none of those steps exist.

How to Deploy a Ruby on Rails App on Kuberns (Step by Step)

Kuberns is an agentic AI deployment platform that automates the Rails production checklist - migrations, asset compilation, Puma config, SSL, and autoscaling - without requiring a Procfile, YAML, or Dockerfile. It’s built on AWS infrastructure and is one of the more complete automation options available for Rails in 2026.

Here’s the full deployment walkthrough:

Step 1: Create Your Kuberns Account

Go to kuberns.com and click Deploy for Free. Create your account and verify your phone number.

Kuberns has a free tier to start. After that, $7 gets you $14 in compute credits - 2x value to apply toward your deployment. See what each tier includes.

Step 2: Connect Your GitHub Repository

On the Creating a Service page, connect your GitHub account and select your Rails repository and branch.

Click Connect & Configure and authorise Kuberns access to your repositories
Select your Rails repository and the branch you are deploying (typically main)
The AI scans your project, detects the Rails stack, and configures the build and start commands - you confirm, not configure

Step 3: Add Environment Variables

Before clicking Deploy, navigate to the Environment section:

Click Add Env Vars and input key-value pairs manually, or
Click Upload .env file to import all variables at once

Add your DATABASE_URL, SECRET_KEY_BASE, RAILS_ENV, and the other variables from the table above. Kuberns encrypts all values at rest and they never appear in build logs.

Step 4: Click Deploy - The AI Takes Over

Click Deploy. From here you watch rather than configure. The Kuberns agentic AI:

Runs bundle install to install all gems from your Gemfile
Detects Rails and configures Puma with the correct number of workers
Runs rails db:migrate automatically - your database schema is updated
Runs rails assets:precompile automatically - CSS, JS and images are ready
Provisions AWS compute in your chosen region
Issues an SSL certificate - your URL is HTTPS from the first request
Enables CI/CD - every GitHub push triggers an automatic redeploy with migrations re-run

Step 5: Access Your Live Rails App

Your Rails app is live. From the Kuberns dashboard you can:

Open your deployed HTTPS URL
View live usage stats and resource consumption
Check real-time logs and build history
Manage environment variables without redeploying
Monitor AI-driven autoscaling metrics

Deploy your Rails app on Kuberns →

What Gets Automated vs What You Still Configure

This table covers what Kuberns handles automatically versus what requires manual work on other platforms:

Rails Production Requirement	Manual VPS	Heroku	Render / Railway	Kuberns
Puma server config	Write config file	Procfile required	Procfile required	AI automatic
`rails db:migrate`	Run manually after each deploy	Release phase script	Manual pre-deploy command	AI automatic
`rails assets:precompile`	Run manually	Buildpack	Manual build command	AI automatic
PostgreSQL setup	Manual DB + pg_hba.conf	Add-on (paid)	Plugin / add-on	Environment variable
`SECRET_KEY_BASE`	Manual credentials config	Config vars	Environment vars	Environment vars
Static file serving	Nginx config	Buildpack	Manual	`RAILS_SERVE_STATIC_FILES`
SSL certificate	Certbot + cron renewal	Automatic	Automatic	Automatic
Autoscaling	Manual load balancer rules	Dyno scaling (paid)	Rules-based	AI-driven, traffic-based
Sidekiq workers	Separate systemd service	Separate worker dyno	Separate service	Background worker via dashboard
Zero-downtime deploys	Manual blue/green setup	Varies	Varies	Automatic
Monitoring + logs	Prometheus / Datadog setup	Basic	Basic	Built-in, zero setup

Handling Rails-Specific Production Requirements

PostgreSQL with Rails on Kuberns

Kuberns does not provision a managed database by default. The most common approach is to connect an external PostgreSQL instance via DATABASE_URL. You can use any of the following:

Neon - serverless PostgreSQL, generous free tier
Supabase - PostgreSQL with a dashboard, free tier available
Railway PostgreSQL plugin - if you want everything in one place
Any PostgreSQL provider that gives you a connection string

Paste the connection string as DATABASE_URL in your Kuberns environment variables. Kuberns reads it, database.yml reads from it, and rails db:migrate runs automatically on every deploy.

Sidekiq Background Jobs

If your Rails app uses Sidekiq for background processing - emails, webhooks, report generation - you need it running as a separate process alongside the web server.

On Heroku this meant a separate worker dyno billed separately. On a VPS this meant a separate systemd service. On Kuberns, you add a background worker from the dashboard with the start command bundle exec sidekiq. Kuberns manages the Sidekiq process independently and restarts it if it crashes.

For apps with multiple services - Rails API, Sidekiq worker, and a frontend - see our guide on running background workers alongside your main app.

Active Storage

If your app uses Active Storage for file uploads, configure it to use an S3-compatible service in production. Add these environment variables:

AWS_ACCESS_KEY_ID=your_key
AWS_SECRET_ACCESS_KEY=your_secret
AWS_REGION=ap-south-1
AWS_BUCKET=your_bucket_name

Then in config/storage.yml use the Amazon service, and in config/environments/production.rb set config.active_storage.service = :amazon.

Action Cable / WebSockets

Action Cable works in production on Kuberns. Configure it to use Redis as the cable adapter:

# config/cable.yml
production:
  adapter: redis
  url: <%= ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" } %>

Add REDIS_URL as an environment variable pointing to your Redis instance.

Ruby on Rails Deployment Platform Comparison (2026)

Platform	Auto Migrate	Auto Precompile	Procfile Needed	Free Tier	Built on	Best For
Kuberns	✅ AI automatic	✅ AI automatic	❌ Not needed	✅ $14 credits	AWS	Full-stack Rails, zero-ops teams
Heroku	❌ Release phase script	❌ Buildpack	✅ Required	❌ None	Salesforce	Legacy Rails, enterprise
Render	❌ Manual script	❌ Manual build cmd	✅ Required	⚠️ Limited	AWS	Heroku migrations
Railway	❌ Manual command	❌ Manual	✅ Required	⚠️ $5 trial	GCP	Prototypes
Fly.io	❌ Manual	❌ Manual	✅ Dockerfile	⚠️ Limited	Own infra	Devs who prefer config
VPS (Manual)	❌ Manual	❌ Manual	❌ Full setup	❌ None	Any	DevOps-heavy teams

If you are evaluating alternatives to Railway for your Rails app, see our guide to the best Railway alternatives for Rails deployment.

If you have been using Render and are looking for something with less manual configuration, our Render alternatives for production apps guide compares the top options.

Choosing the Right Platform for Your Rails App

The right deployment platform depends on how much configuration you’re willing to manage and what your budget looks like.

Heroku is still a valid choice for teams already on it. The developer experience is polished and Rails support is mature. The main friction is cost - dynos add up quickly, and the free tier is gone.

Render is the most popular Heroku migration target. It supports Rails well but still requires a Procfile and manual build commands. The free tier has cold start delays.

Railway is good for prototypes and early-stage projects. It’s fast to set up but less suited for production apps that need reliable autoscaling and zero-downtime deploys.

Fly.io gives you the most control but requires Docker and a deeper understanding of infrastructure. Not ideal if you want to move fast.

Kuberns automates the full Rails production checklist - migrations, asset compilation, Puma config, SSL, autoscaling - without configuration files. It’s built on AWS and offers up to 40% cost savings compared to running AWS directly. Free credits of $14 are available to test before committing.

For a deeper comparison of these platforms, read what Kuberns is and how it works.

Conclusion

Deploying a Ruby on Rails app to production has always required more setup than most frameworks. Puma config, database migrations, asset compilation, background workers - Rails doesn’t cut corners, and neither should your deployment process.

The platforms available in 2026 range from full manual control on a VPS to near-complete automation. Which one is right depends on your team’s size, budget, and tolerance for configuration overhead.

If you want the fastest path from a GitHub repo to a live Rails app - with migrations, assets, SSL, and autoscaling handled automatically - Kuberns is worth starting with. The free credits mean you can test a real deployment before making any commitments.

For teams evaluating other options, our guides on Railway alternatives and Render alternatives cover the full landscape.

Frequently Asked Questions

What is the easiest way to deploy a Ruby on Rails app in 2026?

The easiest way is using Kuberns. Connect your GitHub repository, add environment variables including DATABASE_URL and SECRET_KEY_BASE, and click Deploy. Kuberns AI automatically runs db:migrate, compiles assets, configures Puma, and enables autoscaling - no Procfile or YAML required.

Do I need a Procfile to deploy Rails on Kuberns?

No. Kuberns detects your Rails project automatically and configures Puma without a Procfile. You do not need to specify a web or worker process type manually.

How do I run rails db:migrate automatically on deployment?

On Kuberns, rails db:migrate runs automatically on every deployment before the app starts. There is no release phase script or manual command needed.

Can I deploy Rails without Heroku?

Yes. Platforms like Kuberns, Render, and Railway are all strong Heroku alternatives for Rails. Kuberns is the only one that fully automates migrations, asset compilation, and Puma configuration without any configuration files.

How do I deploy Rails with Sidekiq background jobs?

On Kuberns, add a background worker service from the dashboard with the start command bundle exec sidekiq. Kuberns manages the Sidekiq process separately and restarts it automatically if it crashes, without needing a separate Procfile entry or dyno.

How long does it take to deploy a Rails app with Kuberns?

Most Rails apps are live within 5 to 10 minutes of clicking Deploy on Kuberns, including database migration and asset compilation.

Can I deploy a Rails app without Docker?

Yes. Kuberns does not require a Dockerfile. The platform handles containerisation internally so you never need to write or manage Docker configuration.

What is the best Heroku alternative for Ruby on Rails in 2026?

Kuberns is the strongest Heroku alternative for Rails in 2026. It automates migrations, asset precompilation, Puma config, SSL, and autoscaling out of the box. Unlike Heroku, pricing is not per-dyno and the platform is built on AWS with up to 40% lower cost than running on AWS directly.