Ruby on Rails is a full-stack web application framework emphasizing convention over configuration, featuring Active Record ORM, integrated asset bundling, and streamlined deployment tooling.
When to Use
- High-Velocity Full-Stack Web Development: Building robust SaaS products with convention over configuration.
- Modern Monoliths with Hotwire / Turbo: Delivering reactive, SPA-like user experiences without heavy frontend frameworks.
- Database-Driven Business Applications: Leveraging Active Record associations, scopes, and validations.
- Background Jobs & Real-Time WebSockets: Utilizing Solid Queue, Solid Cache, and Action Cable in Rails 7.2 / 8.
Quick Start
# app/controllers/posts_controller.rb
class PostsController < ApplicationController
def index
@posts = Post.all
end
end
Core Concepts
Active Record Models with Scopes & Validations
Defining business logic and relational constraints:
class Order < ApplicationRecord
belongs_to :customer
has_many :line_items, dependent: :destroy
validates :total_amount, presence: true, numericality: { greater_than: 0 }
validates :status, inclusion: { in: %w[pending paid shipped canceled] }
scope :recent, -> { order(created_at: :desc) }
scope :paid, -> { where(status: 'paid') }
after_commit :enqueue_fulfillment, on: :create
private
def enqueue_fulfillment
FulfillmentJob.perform_later(id)
end
end
Hotwire & Turbo Streams for Real-Time Updates
Server-rendered partials pushed over WebSockets or response streams:
# app/controllers/messages_controller.rb
class MessagesController < ApplicationController
def create
@message = Message.create!(message_params)
respond_to do |format|
format.turbo_stream do
render turbo_stream: turbo_stream.append(
'messages_list',
partial: 'messages/message',
locals: { message: @message }
)
end
format.html { redirect_to @message.room }
end
end
end
Background Processing with Active Job
Asynchronous queue job execution:
class FulfillmentJob < ApplicationJob
queue_as :default
retry_on Net::OpenTimeout, wait: :exponentially_longer, attempts: 3
def perform(order_id)
order = Order.find(order_id)
OrderFulfillmentService.new(order).process!
end
end
Common Patterns
Turbo Stream Real-Time Dom Updates (Hotwire)
Problem: Needing single-page app reactivity without complex React/Vue frontend builds.
Solution: Broadcast model updates via Turbo Streams:
# app/models/message.rb
class Message < ApplicationRecord
belongs_to :room
after_create_commit -> {
broadcast_append_to room, target: "messages", partial: "messages/message", locals: { message: self }
}
end
Best Practices
Do:
- Target Rails 7.2 / 8 with Propshaft asset pipeline and built-in Solid Queue / Solid Cache.
- Always use strong parameters (
params.require(:order).permit(...)) in controllers. - Use
includesorstrict_loadingto prevent N+1 query performance degradation. - Encapsulate complex multi-model business logic inside Plain Old Ruby Object (PORO) service objects.
Don't:
- Put business logic or complex database queries inside view templates or controllers.
- Run long-running tasks synchronously inside HTTP controller actions; offload to Active Job.
- Skip database indexes on foreign keys; declare them explicitly in migrations.
Troubleshooting
| Error | Cause | Solution |
|---|---|---|
ActiveRecord::RecordNotFound |
find(id) called with non-existent primary key. |
Use find_by(id: ...) or handle rescue in ApplicationController. |
ActionController::InvalidAuthenticityToken |
CSRF token missing or mismatch in POST/PATCH request. | Include <%= csrf_meta_tags %> in layout or verify headers. |
PendingMigrationError: Migrations are pending |
Database schema out of date with migration files. | Run bin/rails db:migrate. |