Ruby

Rails, Sinatra, and Rack deployed from Git

Connect a repository and push. We detect your framework, build a container with your assets precompiled, and serve it with Puma - health-checked, and rolled back in one click when you need it.

Start free trial See pricing

14 days free. No credit card. No commitment.

Push to deploy

GitHub, GitLab, Bitbucket

Multi-stage build

Assets precompiled

One-click rollback

Promote any build

Same price

On renewal, every year

99.99%

Uptime, last 12 mo

Daily

Backups kept up to 30 days

210+

Tasks Ellie handles

Frameworks

Three shapes, one pipeline

We read your repository, work out which of these your app is, and start it the right way. Every command is a starting point you can override in the build settings.

Rails

Puma

The full-stack option, recognised from bin/rails and the gem in your Gemfile, and served by Puma with your own config.

Detected from: bin/rails and gem "rails"
Start command: $ bundle exec puma -C config/puma.rb
Environment: RAILS_MASTER_KEY or SECRET_KEY_BASE. RAILS_ENV and PORT are set for you.

Sinatra

Rack

The small one. Detected from the gem plus a config.ru, and started through rackup with Puma behind it.

Detected from: gem "sinatra" and config.ru
Start command: $ bundle exec rackup -s puma -o 0.0.0.0 -p $PORT
Environment: RACK_ENV and PORT are set for you.

Any Rack app

config.ru

Roda, Grape, Hanami, Padrino, or something you wrote yourself. If it answers to Rack, a config.ru is all we need.

Detected from: config.ru, with no framework gem required
Start command: $ bundle exec puma config.ru -b tcp://0.0.0.0:$PORT
Environment: RACK_ENV and PORT are set for you.

What you get

A real deployment pipeline, built in

Connect a repository once and every push runs through the same build, health-check, and promote pipeline - with rollback always one click away.

Git push deploys

GitHub, GitLab, or Bitbucket over OAuth or a token. A push registers a webhook and triggers a build automatically.

Framework detection

Rails, Sinatra, or Rack recognized from your project. Build and start commands set for you, fully overridable.

Multi-stage Rails builds

Assets precompile in a build stage; Node and Yarn are added automatically when jsbundling or cssbundling is present.

MySQL ready

Your database host is injected into the container and read straight from ENV. Connect over TCP with panel-managed credentials.

Blue/green deploys

A new build starts on a fresh port and only takes traffic after a health check passes. A failed build never reaches visitors.

One-click rollback

Every successful build is kept. Promote a previous one back to live in seconds - no rebuild, no Git revert.

Env vars & secrets

Runtime variables injected into the process. Mark any as a secret and the value is sealed - write-only, never shown again.

Live logs

Stream Puma output and platform events straight from the panel. See what happened without opening SSH.

How it works

Push. Build. Live.

Three Git providers, one pipeline. Choose ship-on-every-push, or build-and-hold until you promote it yourself.

Connect your repository

Link GitHub, GitLab, or Bitbucket via OAuth or a token, pick the repo and branch, and a push webhook is registered for you.

We detect and build

Each push clones the commit, detects Rails, Sinatra, or Rack, installs the gems your Gemfile.lock pins, precompiles assets, and packages a versioned image.

Health-check and promote

The container has to answer on its port within 30 seconds before it goes live. On Auto deploy it promotes itself; on Build only it waits for you.

Build #v9

Current

Repositoryrails-app / main

FrameworkRails

Ruby3.4

Port3000

Build log

✓ Detected Rails · bundler 2.5

✓ bundle install (from lockfile)

✓ assets:precompile

✓ puma bound 0.0.0.0:3000

✓ Health check passed · promoted

The pipeline

What happens between push and live

Five stages, every time, with the previous build kept the whole way through.

Push
A commit lands on the tracked branch.
Detect
bin/rails, your Gemfile, or a bare config.ru tells us which of the three shapes your app is.
Build
Bundler installs in a resource-capped container. The result is a versioned image.
Health check
The new container must answer on its port within 30 seconds.
Live
It takes over traffic. The previous build stays, one click away.

Runtime

A real container, with a live view of it

Your app is a managed service with its own resources, automatic restarts, and logs you can read without opening SSH.

Config comes from ENV, always
Values are read straight from ENV at process start. Nothing is baked into the image, so rotating a secret is a restart rather than a rebuild.
RAILS_ENV and PORT are set for you
The two variables every Ruby deploy guide tells you to remember are already in the container. You supply the master key and, if you want one, a DATABASE_URL.
DATABASE_URL is optional
Set it and Rails uses it. Leave it out and the app falls back to the DB_* variables pointed at your MySQL host, which the panel already manages.
Gems checked after the build
Your Gemfile.lock is read at build time and re-checked nightly against the public advisory database, so an advisory published after your last deploy still reaches you, with the version that clears it.
Three versions, pinned
Ruby 4.0, 3.4 or 3.3. Pick one in the panel or pin it in your repo, and it stays pinned across deploys.

Databases, right where you expect them

Create MySQL databases and users in the panel, then reach them from your Rails app over TCP. The host is injected into ENV for you, and phpMyAdmin is one click away for browsing.

See the developer tooling

Pricing

Simple, transparent pricing

Every plan includes managed WordPress, SSH access, daily backups, and enterprise-grade security. Start with a 14-day free trial.

Startup

Great for growing businesses

$7.99/mo

$94.99 billed annually

Get started

1 website
10 GB storage
~10,000 visits/month
5 MySQL databases
250,000 inodes
5 FTP users

What's included:

SSL & Domain

Free SSL certificate
Free starter domain

2 mailboxes
3 GB per mailbox
Webmail, IMAP and SMTP

Advanced

For professional websites

$14.99/mo

$179.99 billed annually

Choose plan

5 websites
20 GB storage
~110,000 visits/month
10 MySQL databases
500,000 inodes
10 FTP users

Everything in Startup, plus:

5 mailboxes
5 GB per mailbox

Backups

14 days of backup history

Performance

Memcached object cache
Redis object cache

Pro

Maximum performance and features

$22.99/mo

$274.99 billed annually

Go pro

10 websites
40 GB storage
~200,000 visits/month
20 MySQL databases
750,000 inodes
20 FTP users

Everything in Advanced, plus:

10 mailboxes
10 GB per mailbox

Deployment

2 SSR applications

Backups

30 days of backup history

Monitoring

1 minute between checks

Compare plans

Ship it

Deploy your Ruby app in minutes

Connect a repo, push, and watch it go live under Puma. Included in every plan. Start free for 14 days, no credit card.

Start your free trial

Questions

Frequently asked questions

Which Ruby frameworks are supported?

Ruby on Rails, Sinatra, and any Rack-based app (Roda, Grape, Hanami, Padrino, and others). Rails is detected from bin/rails; Sinatra and generic Rack apps are detected from your Gemfile and config.ru. We set the build and start commands for you, and you can override them.

Which Ruby version can I run?

Ruby 4.0, 3.4, or 3.3. We recommend 3.4. Set it in the build settings, or let us read it from .ruby-version, the ruby directive in your Gemfile, or your Gemfile.lock.

Do I need a Gemfile.lock?

Yes. A committed Gemfile.lock is required so the build installs the exact gem versions your app expects. We also read the "BUNDLED WITH" line to pin the right Bundler version. If it’s missing, the build stops with a clear message rather than guessing.

How is my app served?

With Puma. Rails runs through your config/puma.rb; Sinatra and Rack apps run via rackup or Puma directly against config.ru. Everything binds to the port we provide, and you can tune workers and threads in your Puma config.

Does Rails asset compilation work?

Yes. Rails apps build as a multi-stage image with asset precompilation. If your app uses jsbundling-rails or cssbundling-rails, we install Node and Yarn during the build so your JavaScript and CSS bundles compile.

What port does my app bind to?

Bind to 0.0.0.0 on the port from the PORT environment variable (3000 by default for Ruby). Puma takes the bind address on the command line, which we set for you. Binding to localhost is the usual reason an app builds but won’t start.

Can Rails connect to MySQL?

Yes. Your database host is injected into the container as an environment variable and read directly from ENV, so there’s no .env file to manage. Connect over TCP with the credentials you manage in the panel, or set your own DATABASE_URL.

Is Ruby hosting included in my plan?

Yes. Git deployment, container hosting, rollback, live logs, and environment management are part of every plan. A Ruby app runs in a container that counts against your plan’s app allowance.