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.

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

14-day free trial

No credit card required

99.9% uptime SLA

Container isolation

Using an AI coding assistant?

Point it at the plain-text build guide so it configures your deploy correctly. It is the same contract our docs describe, formatted for machines.

Deploying a specific stack?Node.js Nuxt Python Ruby Static & SPA Build guide

$ curl https://www.hostney.com/build-guide.txt

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

Apps & CMS

1-click WordPress
Managed WordPress
WordPress staging

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:

Backups

14 days of backup history

Performance

Memcached

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:

Deployment

2 SSR applications

Backups

30 days of backup history

Compare plans

Frameworks

Rails to bare Rack, all served by Puma

We detect what you’re running from bin/rails, your Gemfile, and config.ru, then wire up the right start command.

Ruby on Rails

Detected from bin/rails. We build a multi-stage image, precompile assets, and serve with Puma. If your app uses jsbundling or cssbundling, Node and Yarn are installed for you.

$ bundle exec puma -C config/puma.rb

Sinatra

Detected from your Gemfile and config.ru. We run your Rack app under Puma with a lightweight footprint - ideal for small services and APIs.

$ bundle exec rackup -s puma

Rack (any)

A config.ru is all we need. Roda, Grape, Hanami, Padrino - if it speaks Rack, it runs under Puma with the port wired up for you.

$ bundle exec puma config.ru

A committed Gemfile.lock is required - we install the exact gems it pins, and match your Bundler version to it.

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

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

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