10 Advanced Ruby on Rails Features

I recently saw a great article posted by an engineer about advanced tips and tricks in Python (https://blog.edward-li.com/tech/advanced-python-features/) which got me thinking about similar features in Ruby on Rails. Even after 10 years working inside large Rails codebases, here's some features that I've discovered recently working with our clients from NextLink Labs (https://nextlinklabs.com) that make Rails faster, safer, and a lot more fun. Below are my top ten, each paired with a minimal example you can drop into any 6.1 + app (most work on 7.0–7.2). Table of Contents Strict Loading Asynchronous Queries Multi-Database Connection Switching & Sharding Delegated Types Active Record Encryption Attributes API & Custom Types Turbo-Stream Broadcasting from Models Built-in Rate Limiting One-Command Dev Containers Ignoring Counter Caches While Backfilling Default GitHub CI Workflow YJIT as the Default JIT Engine Browser Version Guard Out-of-the-Box PWA Files 1. Strict Loading Raise an error the moment an association lazy-loads, catching N + 1 problems while you code rather than in production. class Article < ApplicationRecord strict_loading_by_default end 2. Asynchronous Queries Off-load expensive SQL to a background pool while the request keeps executing. posts = Post.published.order(created_at: :desc).load_async authors = Author.popular.limit(10).load_async When you finally call posts.each, the records are already waiting in memory. 3. Multi-Database Connection Switching & Sharding Read-replica traffic and horizontal shards are first-class citizens. AnimalsRecord.connected_to(role: :reading) { Report.last } TenantsRecord.connected_to(shard: :europe) do Invoice.create!(...) end 4. Delegated Types A clean alternative to both STI and polymorphic associations. class Entry < ApplicationRecord delegated_type :entryable, types: %w[Post Comment] end Entry.first.entryable transparently returns the concrete model with zero casting or multi-table joins. 5. Active Record Encryption Transparent, per-attribute encryption baked into Rails 7. class User < ApplicationRecord encrypts :ssn, deterministic: true end Rails handles key rotation, blind-index search, and log filtering—no extra gems required. 6. Attributes API & Custom Types Cast arbitrary data into Ruby objects without virtual-attribute hacks. class MoneyType < ActiveModel::Type::Integer def serialize(value) = (value.to_f * 100).to_i def deserialize(value) = value.to_i / 100.0 end class Product < ApplicationRecord attribute :price, MoneyType.new end Validations, serializers, and forms treat price as a float while the database stores cents. 7. Turbo-Stream Broadcasting from Models Real-time UI updates with a single callback. class Message < ApplicationRecord after_create_commit -> { broadcast_append_to :chat } end Every new message pushes a fragment to subscribed browsers—no controller code, no JavaScript. 8. Built-in Rate Limiting Rails 7.2 ships with rate_limit, ending the reign of Rack-Attack. class Api::SessionsController < ActionController::API rate_limit to: 10, within: 1.minute, only: :create end Exceeding the limit triggers an automatic HTTP 429. 9. Browser Version Guard Block outdated browsers via a declarative whitelist. class ApplicationController

Apr 23, 2025 - 12:18

I recently saw a great article posted by an engineer about advanced tips and tricks in Python (https://blog.edward-li.com/tech/advanced-python-features/) which got me thinking about similar features in Ruby on Rails.

Even after 10 years working inside large Rails codebases, here's some features that I've discovered recently working with our clients from NextLink Labs (https://nextlinklabs.com) that make Rails faster, safer, and a lot more fun. Below are my top ten, each paired with a minimal example you can drop into any 6.1 + app (most work on 7.0–7.2).

Strict Loading
Asynchronous Queries
Multi-Database Connection Switching & Sharding
Delegated Types
Active Record Encryption
Attributes API & Custom Types
Turbo-Stream Broadcasting from Models
Built-in Rate Limiting
One-Command Dev Containers
Ignoring Counter Caches While Backfilling
Default GitHub CI Workflow
YJIT as the Default JIT Engine
Browser Version Guard
Out-of-the-Box PWA Files

1. Strict Loading

Raise an error the moment an association lazy-loads, catching N + 1 problems while you code rather than in production.

class Article < ApplicationRecord
  strict_loading_by_default
end

2. Asynchronous Queries

Off-load expensive SQL to a background pool while the request keeps executing.

posts   = Post.published.order(created_at: :desc).load_async
authors = Author.popular.limit(10).load_async

When you finally call posts.each, the records are already waiting in memory.

3. Multi-Database Connection Switching & Sharding

Read-replica traffic and horizontal shards are first-class citizens.

AnimalsRecord.connected_to(role: :reading) { Report.last }

TenantsRecord.connected_to(shard: :europe) do
  Invoice.create!(...)
end

4. Delegated Types

A clean alternative to both STI and polymorphic associations.

class Entry < ApplicationRecord
  delegated_type :entryable, types: %w[Post Comment]
end

Entry.first.entryable transparently returns the concrete model with zero casting or multi-table joins.

5. Active Record Encryption

Transparent, per-attribute encryption baked into Rails 7.

class User < ApplicationRecord
  encrypts :ssn, deterministic: true
end

Rails handles key rotation, blind-index search, and log filtering—no extra gems required.

6. Attributes API & Custom Types

Cast arbitrary data into Ruby objects without virtual-attribute hacks.

class MoneyType < ActiveModel::Type::Integer
  def serialize(value)   = (value.to_f * 100).to_i
  def deserialize(value) = value.to_i / 100.0
end

class Product < ApplicationRecord
  attribute :price, MoneyType.new
end

Validations, serializers, and forms treat price as a float while the database stores cents.

7. Turbo-Stream Broadcasting from Models

Real-time UI updates with a single callback.

class Message < ApplicationRecord
  after_create_commit -> { broadcast_append_to :chat }
end

Every new message pushes a fragment to subscribed browsers—no controller code, no JavaScript.

8. Built-in Rate Limiting

Rails 7.2 ships with rate_limit, ending the reign of Rack-Attack.

class Api::SessionsController < ActionController::API
  rate_limit to: 10, within: 1.minute, only: :create
end

Exceeding the limit triggers an automatic HTTP 429.

9. Browser Version Guard

Block outdated browsers via a declarative whitelist.

class ApplicationController < ActionController::Base
  allow_browser safari: "16", chrome: "110", firefox: "112"
end

10. Out-of-the-Box PWA Files

Rails 7.2 generators include a manifest and service-worker template under /pwa, making an installable, offline-capable Progressive Web App a few edits away.

Conclusion

That’s a whirlwind tour through some more advanced features that I've learned and found useful in my recent work. How many were new to you? Drop me a note—I’d love to hear about your examples of useful Rails features.

If you're struggling with a legacy Rails app or looking for any kind of help with your application, feel free to send us a message here (https://nextlinklabs.com/contact)

You might also find some of my other blog posts useful:

Common Types of Rails Technical Debt

Six Tips For Inheriting a Legacy Rails App