Quickstarters
How to Build a Backend for Ruby On Rails?

34min
Introduction
In this tutorial, you’ll learn how to build a backend for Ruby on Rails using Back4App. 
We’ll explore the key steps to integrate your Rails application with essential Back4App features—like database interactions, Cloud Code Functions, REST and GraphQL APIs, user authentication, and real-time queries (Live Queries)—all running on the server side. 
By leveraging the Ruby programming language, you’ll build a robust and scalable architecture that aligns with the view controller MVC pattern in Rails, enabling developers to speed up web application development.
You’ll also discover how Back4App drastically reduces time and effort by simplifying server and database management. 
These automated features can save you from manually setting up a web server or dealing with complex infrastructures. 
By the end, you’ll possess a flexible and secure structure, ready for production or further expansions—like additional integrations and advanced custom logic. 
Whether you want to serve web pages or power data-driven web applications, Rails and Back4App offer a seamless synergy for creating modern solutions in popular programming languages.
Prerequisites
To complete this tutorial, you will need:
A Back4App account and a new Back4App project
 Getting Started with Back4app.
If you do not have an account, you can create one for free. Follow the guide above to get your project ready.
A Ruby on Rails development environment
Ensure you have Ruby installed (preferably version 2.7 or above) and the Rails gem (Rails 6 or above). Install Rails﻿
Parse Ruby Client
If you intend to use the Parse SDK directly, you can install the parse-ruby-client gem to handle data operations with Back4App.
Familiarity with Rails MVC
If you’re new to Ruby on Rails, review the official Rails guides or a beginner’s tutorial to understand Rails’ view controller MVC architecture before starting.
Make sure these prerequisites are in place before you begin. Having your Back4App project set up, plus your Rails application scaffold ready, ensures a smooth tutorial experience.
Step 1 – Creating a New Project on Back4App and connecting
Create a New Project
The first step in setting up a server side backend for your Rails application is creating a new project on Back4App. If you haven't done so:
Log in to your Back4app account.
Click the “New App” button in your Back4App dashboard.
Give your app a name (e.g., “Rails-Backend-Tutorial”).
﻿
Once the project is created, it will be visible in your Back4App dashboard. This new project forms the core of all backend configurations in this tutorial.
Connect the Parse SDK (Optional: parse-ruby-client)
To streamline database interactions and real-time queries, Back4App uses the Parse platform. If you want to integrate your Rails server with Parse directly, you may install the parse-ruby-client gem. Otherwise, you can rely on standard REST or GraphQL endpoints.
Retrieve your Parse Keys:
In your Back4App dashboard, go to your app’s “App Settings” or “Security & Keys” to find your Application ID and REST API Key. You’ll also get your Parse Server URL (e.g., https://parseapi.back4app.com).
﻿
Add the parse-ruby-client gem to your Gemfile:
Ruby
gem 'parse-ruby-client'
gem 'parse-ruby-client'
﻿
Then run:
Bash
bundle install
bundle install
﻿
Initialize Parse in an initializer, such as config/initializers/parse.rb:
Ruby
# config/initializers/parse.rb
require 'parse'

Parse.init application_id:  'YOUR_APPLICATION_ID',
           api_key:         'YOUR_REST_API_KEY',
           server_url:      'https://parseapi.back4app.com'
# config/initializers/parse.rb
require 'parse'

Parse.init application_id:  'YOUR_APPLICATION_ID',
           api_key:         'YOUR_REST_API_KEY',
           server_url:      'https://parseapi.back4app.com'
﻿
At this point, your Rails application is able to communicate with Back4App for storing and retrieving data, orchestrating custom logic, and more. This integrated approach simplifies how your Ruby on Rails app handles the backend.
Step 2 – Setting Up the Database
Creating a Data Model
In many web applications, you define your data structure in Rails using ActiveRecord migrations. With Back4App, you also have the option to build your schema directly on the dashboard. For example, if you have a Todo model:
Navigate to “Database” in your Back4App dashboard.
Create a new class named “Todo” and add columns like title (String) and isCompleted (Boolean).
Create New Class
﻿
Back4App supports String, Number, Boolean, Date, File, Pointer, Relation, Array, GeoPoint, and Polygon. Rails typically manages these within its model definitions, but you can also let Parse create columns automatically on first save (if you use the Parse SDK or REST/GraphQL APIs).
Create Column
﻿
Creating a Data Model Using the AI Agent
Back4App’s AI Agent can automate schema creation:
Open the AI Agent from your dashboard.
Describe your data model (e.g., “Please create a new ToDo App with a complete class schema.”).
Let the agent generate your schema.
﻿
Reading and Writing Data using SDK
If you choose to integrate the parse-ruby-client, you can store a record like this:
Ruby
# app/controllers/todos_controller.rb

def create
  todo_class = Parse::Object.new('Todo')
  todo_class['title']       = params[:title]
  todo_class['isCompleted'] = false

  begin
    todo_class.save
    render json: { message: 'Todo saved successfully' }
  rescue => e
    render json: { error: e.message }, status: 500
  end
end

def index
  query = Parse::Query.new('Todo')
  results = query.get
  render json: results
end
# app/controllers/todos_controller.rb

def create
  todo_class = Parse::Object.new('Todo')
  todo_class['title']       = params[:title]
  todo_class['isCompleted'] = false

  begin
    todo_class.save
    render json: { message: 'Todo saved successfully' }
  rescue => e
    render json: { error: e.message }, status: 500
  end
end

def index
  query = Parse::Query.new('Todo')
  results = query.get
  render json: results
end
﻿
Reading and Writing Data using REST API
Alternatively, you can use REST calls from within your Rails code (or any external client). For instance, to create a Todo:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Finish Rails Guide", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Finish Rails Guide", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
﻿
Reading and Writing Data using GraphQL API
Back4App also offers GraphQL:
GraphQL
mutation {
  createTodo(input: {
    fields: {
      title: "Plan web pages"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTodo(input: {
    fields: {
      title: "Plan web pages"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
﻿
Working with Live Queries (optional)
If you want real-time updates in your Rails application, you can subscribe to Live Queries from a front-end or a WebSocket client. Enable Live Queries in your Back4App Server Settings, then connect to the wss://YOUR_SUBDOMAIN.b4a.io for an ongoing stream of changes. This is helpful for dynamic web applications that need immediate data refreshes.
Step 3 – Applying Security with ACLs and CLPs
Brief Overview
Security is vital in web application development. Back4App offers Access Control Lists (ACLs) and Class-Level Permissions (CLPs) to control data visibility at both the object and class levels. This helps ensure only authenticated or authorized users can read/write sensitive data.
﻿
Setting up Class-Level Permissions
Go to the Database in your Back4App dashboard.
Select a Class (e.g., “Todo”).
Open the CLPs tab to configure read/write access by roles, authenticated users, or the public.
Configuring ACLs
You can set an ACL on an object so that only a specific user can read or modify it. In Rails with parse-ruby-client, it might look like:
Ruby
todo = Parse::Object.new('Todo')
acl  = Parse::ACL.new

# Set read/write for a user
acl.set_read_access_for(user_id, true)
acl.set_write_access_for(user_id, true)

todo.ACL = acl
todo.save
todo = Parse::Object.new('Todo')
acl  = Parse::ACL.new

# Set read/write for a user
acl.set_read_access_for(user_id, true)
acl.set_write_access_for(user_id, true)

todo.ACL = acl
todo.save
﻿
Step 4 – Writing Cloud Code Functions
Why Cloud Code
Cloud Code runs server-side JavaScript, enabling developers to add custom logic, triggers, and validations without managing your own web server. You might want to handle extra server logic or do checks before saving data.
Example Function
Below is an example in JavaScript. While your Rails server handles the main app, you can still use Cloud Code to process data:
JS
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Deployment
Deploy through the Back4App CLI or from the Back4App Dashboard. Cloud Code is a convenient way to encapsulate logic that’s shared among all clients, regardless of which programming languages they use. With node-based modules (NPM) support, you can integrate external packages seamlessly.
Step 5 – Configuring Authentication
Enable User Authentication
Back4App manages user sign-ups, logins, and sessions with Parse’s built-in User class. You can create a user with a REST call or through any official SDK.
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"username": "john", "password": "secretpass"}' \
  https://parseapi.back4app.com/users
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"username": "john", "password": "secretpass"}' \
  https://parseapi.back4app.com/users
﻿
Social Login
You can integrate Facebook, Google, or Apple sign-in flows. Each provider has a slightly different approach, but the main principle is to exchange tokens with Parse. Check the official Social Login Docs for details on how to integrate these into your rails application.
Step 6 – Handling File Storage
Setting Up File Storage
Using Parse for files is as simple as uploading them through the Parse API. If you’re employing the parse-ruby-client:
Ruby
file_data = File.open('path/to/image.jpg')
parse_file = Parse::File.new('image.jpg', file_data)

begin
  parse_file.save
  puts "File uploaded: #{parse_file.url}"
rescue => e
  puts "Error uploading file: #{e.message}"
end
file_data = File.open('path/to/image.jpg')
parse_file = Parse::File.new('image.jpg', file_data)

begin
  parse_file.save
  puts "File uploaded: #{parse_file.url}"
rescue => e
  puts "Error uploading file: #{e.message}"
end
﻿
Example
You can then attach this file to an object:
Ruby
photo_obj = Parse::Object.new('Photo')
photo_obj['imageFile'] = parse_file
photo_obj.save
photo_obj = Parse::Object.new('Photo')
photo_obj['imageFile'] = parse_file
photo_obj.save
﻿
﻿
Step 7 – Email Verification and Password Reset
Enable email verification in your Back4App Dashboard under Email Settings.
Set up password reset by customizing the email template and domain settings.
Trigger email flows automatically after user registration or when a user requests a password reset. This ensures improved security and helps confirm valid email ownership.
Step 8 – Scheduling Tasks with Cloud Jobs
Cloud Jobs
If you want to automate tasks like cleaning data or sending daily summaries, use Cloud Jobs:
JS
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);

  try {
    const oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);

  query.lessThan('createdAt', cutoff);

  try {
    const oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
﻿
You can schedule such jobs in the Back4App Dashboard under Server Settings > Background Jobs to run daily or at desired intervals.
Step 9 – Integrating Webhooks
Webhooks let your Back4App app send data to an external URL whenever certain events happen. You can forward new or updated object data to another system—like Stripe or Slack.
Go to More > WebHooks in your Back4App dashboard.
Add a new webhook pointing to your external URL (e.g., a route in your Rails controller).
Specify the event that triggers the webhook.
Adding a Webhook
﻿
If you prefer, you can also trigger a webhook from Cloud Code by making an HTTP request in a beforeSave or afterSave function.
BeforeSave WebHook
﻿
Step 10 – Exploring the Back4App Admin Panel
The Back4App Admin App offers a user-friendly way for non-technical teams or clients to perform CRUD operations on your Back4App data. This interface eliminates the need for direct code changes or usage of the Parse Dashboard for basic tasks.
Where to Find It
You can enable the Admin App from your dashboard by going to More > Admin App and clicking Enable Admin App.
Enable Admin App
﻿
Features
Once enabled, you can:
Create and manage data without writing queries.
Monitor logs, schedule background jobs, and handle push notifications (if enabled).
Provide role-based access to team members for safer editing.
﻿
Conclusion
Congratulations! You’ve learned how to build a backend for Ruby on Rails using Back4App. In this tutorial, you have:
Configured a Rails project to interact with Back4App via REST, GraphQL, or the Parse Ruby Client.
Set up secure database interactions using class schemas, ACLs, CLPs, and optional Live Queries.
Integrated user authentication with email verification and password resets.
Deployed Cloud Code for custom logic, triggers, and scheduled tasks.
Managed file uploads, harnessed webhooks, and explored the Admin Panel.
By combining Ruby on Rails’ MVC architecture with Back4App’s robust feature set, your rails application can scale seamlessly. 
You’ll save considerable time in managing infrastructure, letting you concentrate on building web applications with refined user experiences and reliable server side logic.
Next Steps
Extend your Rails app by adding more complex relationships, caching strategies, or advanced integrations.
Incorporate third-party APIs (like payment gateways) and harness Cloud Code for deeper web application development.
Explore the official Back4App documentation for advanced security, performance tuning, logs analysis, and more.
Experiment with real-time features to create chat apps or collaborative platforms—ideal for data that changes frequently.
With these fundamentals in place, you can rapidly develop, iterate, and scale your Rails server for modern web applications. Happy coding!
Updated 16 Jan 2025
Did this page help you?
How to Build a Backend for Yii 2?
How to Build a Backend for Ruby?