10 Underrated Ruby on Rails Features to Boost Productivity

Working with Ruby on Rails for a while? Think you know everything? This article highlights ten advanced Ruby on Rails features that can dramatically improve your development workflow, application performance, and overall code quality. Discover new ways to optimize your Rails applications and impress your team!

Table of Contents

• Streamline Development with Strict Loading
• Optimize Performance with Asynchronous Queries
• Scale Your App with Multi-Database Connection Switching
• Simplify Associations with Delegated Types
• Secure Sensitive Data with Active Record Encryption
• Enhance Data Handling with Attributes API & Custom Types
• Build Real-Time Features with Turbo-Stream Broadcasting
• Control Traffic with Built-in Rate Limiting
• Safeguard Users with Browser Version Guard
• Create Installable Apps with Out-of-the-Box PWA Files

Streamline Development with Strict Loading

Tired of N+1 queries crippling your application's performance? Rails offers strict loading to catch these issues early. By enabling strict loading, Rails will raise an error the moment an association attempts to lazy-load, allowing you to identify and fix performance bottlenecks during development, not in production.

class Article < ApplicationRecord
  strict_loading_by_default
end

Optimize Performance with Asynchronous Queries

Need to speed up your Rails application? Asynchronous queries allow you to offload potentially slow SQL queries to a background pool while the rest of your request continues to execute. This can significantly reduce response times and improve the overall user experience.

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

When you subsequently access the results (e.g., posts.each), the data is already loaded into memory, ready to be used.

Scale Your App with Multi-Database Connection Switching

Managing multiple databases can be a complex task. Multi-database connection switching simplifies read-replica traffic management and horizontal sharding. This allows you to easily direct read operations to read replicas and distribute data across multiple shards, improving performance and scalability.

AnimalsRecord.connected_to(role: :reading) { Report.last }
TenantsRecord.connected_to(shard: :europe) do
  Invoice.create!(...)
end

Simplify Associations with Delegated Types

Delegated types provide a cleaner and more efficient alternative to single table inheritance (STI) and polymorphic associations. It avoids multi-table joins, ensuring transparency and simplicity.

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

Entry.first.entryable will transparently return the concrete model (e.g., Post or Comment) without requiring any casting or complex queries.

Secure Sensitive Data with Active Record Encryption

Protecting sensitive user data is paramount. Active Record encryption provides transparent, per-attribute encryption directly within Rails 7. It integrates seamlessly with your models, with key rotation and secure logging features.

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

Rails will handle key rotation, blind-index search, and log filtering, without resorting to external gems needed.

Enhance Data Handling with Attributes API & Custom Types

The Attributes API lets you cast arbitrary data into Ruby objects without resorting to virtual-attribute hacks. This makes it easier to manage complex data types and ensure data consistency throughout your application.

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 the price as a float while the database stores it as cents.

Build Real-Time Features with Turbo-Stream Broadcasting

Need to add real-time updates to your Rails app? Turbo-Stream broadcasting allows you to push UI updates to subscribed browsers with a single callback. Enhance user experience and boost engagement with minimal code.

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

Every new message automatically pushes a <turbo-stream> fragment to subscribed browsers, eliminating the need for complex controller code or extensive JavaScript.

Control Traffic with Built-in Rate Limiting

Protect your API endpoints from abuse and ensure fair usage with Rails 7.2's built-in rate limiting. This feature allows you to easily define rate limits for specific actions, preventing excessive requests and maintaining application stability.

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

Exceeding the defined limit automatically triggers an HTTP 429 response, safeguarding your application from potential overload.

Safeguard Users with Browser Version Guard

Ensure your users have the best and safest experience by blocking outdated browsers using a declarative whitelist with Browser Version Guard.

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

Create Installable Apps with Out-of-the-Box PWA Files

Turn your Rails application into an installable, offline-capable Progressive Web App (PWA) with Rails 7.2's 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

These are just a few of the many advanced features available in Ruby on Rails. By leveraging these tools, you can build more efficient, scalable, and secure applications. Which of these will you start using today?