How to deploy a Rails app to Render

Learn how to deploy your Ruby on Rails application to so that you can focus on code instead of infrastructure.

There are many ways to deploy a Ruby on Rails application to the internet. Between hosting on your own hardware, renting a virtual machine, using a cloud provider, and using a platform, the opportunities are endless. The low-hassle way to host a Rails application is to use a Platform as a Service (PaaS). In this article, we'll show you how to deploy a Rails Application to, and as a bonus, monitor it with Honeybadger! You can find the final project here on Github.

Going a step further than cloud hosting and using a platform to deploy your web apps provides incredible convenience at a cost. Under the hood, platforms such as Render and Heroku use Amazon Web Services or other cloud providers. Using a platform will cost you more than using a cloud provider directly, as the service is marked up. For the extra cost, you'll be able to deploy and scale a functional service without needing to understand or manage the underlying infrastructure. You'll also gain features like replication, autoscaling, and preview deployments without extra setup. Cloud providers are complicated enough to have built an ecosystem around education and certification, while platforms like Render allow developers to deploy an application in a single sitting.

Setting up an example Ruby on Rails application

If you're reading this, you likely already have a Rails app you'd like to deploy. In case you don't, we'll quickly go over creating a Rails app in this section.

If you don't already have rails installed, install version 7.1.1 with:

gem install rails -v 7.1.1

First, create a new Rails app using the rails new command. We'll pass it a specific version:

rails _7.1.1_ new appname

Next, go into the directory that was created:

cd appname

Next, generate a new model and controller using the scaffold generator. For this example, we'll model "Event":

rails generate scaffold Event title:string date:datetime

This creates a number of files to support Creating, Reading, Updating, and Deleting Event models in a database. We'll run the created database migration to create the necessary Events table next with:

rails db:migrate

The scaffold already generated basic views, models, and controllers to support CRUD actions on events. To see the code in action, run the rails server with:

rails server

Now, visit localhost:3000/events in your browser. You'll see a simple white page with an "Events" header and a "New event" button.

A screenshot of the Events Index Page A screenshot of the Events Index Page

Clicking the button will take you to a form for creating the event, and creating the event will persist it in the database. You can also delete and edit an existing event, all from just the scaffold! This functional CRUD app will serve as a great example for our deployment. Push up the repository to Github as a final step.

Signing up for Render

Signing up for Render is easy. Signing up via Github will save you a step later, as we'll connect to Github to deploy our app. Render's free tier is generous, particularly for folks missing Heroku's free tier.

You can configure your service in the UI, or configure it in your codebase, using infrastructure as code. Many in the DevOps industry prefer infrastructure as code whenever possible, so we'll do that in this example.

Configuring your deployment with deploy.yaml and

Add a file to the root of your repository called render.yaml. In that file, paste this:

  - name: name_of_your_app
    databaseName: name_of_your_app
    user: name_of_your_app
    plan: free

  - type: web
    plan: free
    name: name_of_your_app
    env: ruby
    buildCommand: "./bin/"
    startCommand: "bundle exec puma -C config/puma.rb"
      - key: DATABASE_URL
          name: name_of_your_app
          property: connectionString
      - key: RAILS_MASTER_KEY
        sync: false

In this file, replace name_of_your_app in all places with the name of your app. In our example, we'll call it event_tracker. This specifies that you want a web service and database on the free plan. You'll notice that the file references a build command in a file called bin/, which doesn't exist yet. Create it, and paste the following:

#!/usr/bin/env bash
# exit on error
set -o errexit

bundle install
bundle exec rake assets:precompile
bundle exec rake assets:clean
bundle exec rake db:migrate

This file will execute when your service starts, so they should go here if you need any other custom build steps.

Configuring Postgres as a database adapter

Rails applications begin using SQLite unless specified otherwise when generated. Render requires Postgres, so if your application doesn't yet have it, you'll need to add it.

In your Gemfile, add gem "pg" to the main section of dependencies. Separately, move gem "sqlite3", "~> 1.4" into group: development.

Finally, run a bundle install to update Gemfile.lock.

You must also change your database configuration in database.yml to specify that Postgres should be used in production. Your database.yml should now look like this:

default: &default
  adapter: postgresql
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  timeout: 5000

  <<: *default
  adapter: sqlite3
  database: db/development.sqlite3

# Warning: The database defined as "test" will be erased and
# re-generated from your development database when you run "rake".
# Do not set this db to the same as development or production.
  <<: *default
  database: db/test.sqlite3

  <<: *default
  database: event_tracker_production
  username: event_tracker

You will need to swap out the value for the production database key, event_tracker_production with the name of your app, appended by production. You'll also need to make the username, event_tracker, the name of your application. The environment variable for the production password should have the name of your app as APP_NAME_PASSWORD. Render will automatically set that environment variable with the appropriate value.

Deploying with the Render dashboard

Once you have pushed all your app changes to GitHub, it's time to create your service in the Render dashboard. On the dashboard, select Blueprints, then "New Blueprint Instance." This will allow us to create a new service using our render.yml file.

Select the repository of the application you would like to deploy and give your blueprint a name. You'll also need to paste in your Rails Master Key, which you can get from the file in your repository (which is not checked into git) titled master.key.

A screenshot of the Render dashboard A screenshot of the Render dashboard

Paste in your master key, and let Render work its magic! In a few moments, your Rails application and its database will be live on the web. By default, Render will auto-deploy the service anytime a new commit is made to your default branch. Higher tiers of Render allow for more customization, like preview deployments.

Adding Honeybadger for monitoring

Honeybadger lets you quickly add application health monitoring to your app with minimal setup. After creating an account, add a new project in the dashboard.

A screenshot of the Honeybadger dashboard A screenshot of the Honeybadger dashboard

After selecting your framework (Rails, in this case), you'll be met with some instructions for setting it up.

First, add the honeybadger gem by running:

bundle add honeybadger

Next, run the provided command to generate Honeybadger's configuration files and send a test alert.

Check in your changes and push them to GitHub, and Render will automatically deploy your application with Honeybadger!

To demonstrate the error monitoring, we can write a bug on purpose. For example, I can change my example application's events_controller.rb to have an index method that references a class that I haven't yet written:

def index
  @events = Birthday.all

Committing this and pushing it will auto-deploy the faulty code. After waiting a few minutes for the deploy, we can visit our application's URL and append /events to visit the events index page that contains the bug. Bonus points if you can guess the Ruby error message!

Visiting the /events route throws an error, which is promptly reported to Honeybadger. The error, stack trace, URL, and other helpful information are easily accessible in Honeybadger.

A screenshot of the Honeybadger error page A screenshot of the Honeybadger error page


In conclusion, deploying a Ruby on Rails application using Render offers a straightforward and efficient solution for developers looking to streamline their deployment process. This guide has walked you through setting up a basic Rails app, configuring it for deployment on Render, and integrating Honeybadger for monitoring. The process, though involved, is simplified by the platform's user-friendly interface compared to cloud providers. As the web development landscape continues to evolve, tools like these help developers focus more on creating and less on the complexities of deployment and maintenance.

What to do next:
  1. Try Honeybadger for FREE
    Honeybadger helps you find and fix errors before your users can even report them. Get set up in minutes and check monitoring off your to-do list.
    Start free trial
    Easy 5-minute setup — No credit card required
  2. Get the Honeybadger newsletter
    Each month we share news, best practices, and stories from the DevOps & monitoring community—exclusively for developers like you.
    author photo

    Jeffery Morhous

    Jeff is a Software Engineer working in healtcare technology using Ruby on Rails, React, and plenty more tools. He loves making things that make life more interesting and learning as much he can on the way. In his spare time, he loves to play guitar, hike, and tinker with cars.

    More articles by Jeffery Morhous
    Stop wasting time manually checking logs for errors!

    Try the only application health monitoring tool that allows you to track application errors, uptime, and cron jobs in one simple platform.

    • Know when critical errors occur, and which customers are affected.
    • Respond instantly when your systems go down.
    • Improve the health of your systems over time.
    • Fix problems before your customers can report them!

    As developers ourselves, we hated wasting time tracking down errors—so we built the system we always wanted.

    Honeybadger tracks everything you need and nothing you don't, creating one simple solution to keep your application running and error free so you can do what you do best—release new code. Try it free and see for yourself.

    Start free trial
    Simple 5-minute setup — No credit card required

    Learn more

    "We've looked at a lot of error management systems. Honeybadger is head and shoulders above the rest and somehow gets better with every new release."
    — Michael Smith, Cofounder & CTO of YvesBlue

    Honeybadger is trusted by top companies like:

    “Everyone is in love with Honeybadger ... the UI is spot on.”
    Molly Struve, Sr. Site Reliability Engineer, Netflix
    Start free trial
    Are you using Sentry, Rollbar, Bugsnag, or Airbrake for your monitoring? Honeybadger includes error tracking with a whole suite of amazing monitoring tools — all for probably less than you're paying now. Discover why so many companies are switching to Honeybadger here.
    Start free trial
    Stop digging through chat logs to find the bug-fix someone mentioned last month. Honeybadger's built-in issue tracker keeps discussion central to each error, so that if it pops up again you'll be able to pick up right where you left off.
    Start free trial