Rails 8 Features That Matter for Production Apps

Rails 8 eliminates Redis from the default stack, ships a deployment tool, and generates authentication out of the box. After migrating production applications, here are the features that matter most - and where they fall short.

The Big Picture

Rails 8 eliminates Redis from the default stack by replacing it with database-backed alternatives for jobs, caching, and WebSockets. It also ships Kamal for zero-downtime deployments and doubles down on the “no-build” approach for frontend. Less infrastructure, fewer dependencies, same productivity.

Solid Queue: Built-in Background Jobs

Solid Queue replaces Sidekiq and Redis as the default background job backend in Rails 8. It uses your existing PostgreSQL database for queuing, cutting one service from your infrastructure stack and saving $15-30/month on managed Redis. For most applications processing under 10,000 jobs per minute, it performs comparably to Sidekiq.

I wrote a complete guide to Solid Queue in production that covers configuration, monitoring, and scaling patterns in detail.

Production Example

# app/jobs/payment_processor_job.rb
class PaymentProcessorJob < ApplicationJob
  queue_as :critical

  retry_on PaymentGatewayError, wait: :exponentially_longer, attempts: 5

  def perform(transaction_id)
    transaction = Transaction.find(transaction_id)

    # Process payment with automatic retry and monitoring
    PaymentService.process(transaction)

    # Solid Queue provides built-in monitoring and metrics
    NotificationService.notify_success(transaction.user)
  end
end

Solid Queue provides:

• Concurrency control per queue
• Job prioritization
• Recurring jobs without cron
• Built-in monitoring dashboard

For a typical SaaS application, this eliminates the need for Sidekiq and Redis, reducing your infrastructure by one service.

Solid Cache: Persistent Caching Without Redis

Solid Cache replaces Redis or Memcached with database-backed caching that persists across deploys and restarts. It trades slightly higher latency (1-5ms vs 0.1-0.5ms) for virtually unlimited cache size and simpler operations - one less service to manage, monitor, and pay for.

# config/environments/production.rb
config.cache_store = :solid_cache_store

Solid Cache works well for small to medium applications, development environments, and apps with moderate caching needs. One less service to manage, monitor, and pay for. For a deeper look at configuration and performance benchmarks, see my Solid Cache production guide.

Enhanced Hotwire Integration

Rails 8 makes it practical to build reactive interfaces without JavaScript frameworks with better Turbo Stream support, automatic frame refreshing, refined Stimulus integration, and smoother Turbo Native handling.

Automatic Turbo Frame Refresh

<!-- app/views/dashboards/show.html.erb -->
<%= turbo_frame_tag "metrics",
                     src: metrics_path,
                     refresh: "every 30s" do %>
  <%= render "loading" %>
<% end %>

This simple addition enables real-time dashboards without JavaScript frameworks or WebSocket complexity. Useful for dashboards showing:

• Live transaction metrics and order statuses
• Account balances and inventory levels
• User activity and system metrics

Improved Turbo Native Support

For teams building mobile apps alongside web apps, Turbo Native integration is now seamless:

# app/controllers/application_controller.rb
class ApplicationController < ActionController::Base
  def turbo_native_app?
    request.user_agent.include?("Turbo Native")
  end

  def render_turbo_native_optimized
    if turbo_native_app?
      render layout: "turbo_native"
    end
  end
end

Async Query Methods

Rails 8 async queries run multiple database queries in parallel instead of sequentially, reducing page load times by 40-60% on data-heavy pages. Add .load_async to any ActiveRecord query and the database does the heavy lifting concurrently while your controller continues executing.

# Before Rails 8
def dashboard
  @transactions = Transaction.recent.to_a
  @metrics = Metric.calculate_monthly
  @users = User.active.count

  # Queries run sequentially
end

# Rails 8
def dashboard
  @transactions = Transaction.recent.load_async
  @metrics = Metric.calculate_monthly.load_async
  @users = User.active.count_async

  # Queries run in parallel
end

5. Better Authentication Scaffolding

Rails 8 generates a complete, secure authentication system out of the box - user model, sessions controller, password resets, and bcrypt-based password handling. No gems required for basic auth.

rails generate authentication

This creates a User model with secure password handling, Sessions controller, authentication concerns, and password reset functionality. While Devise remains useful for complex scenarios (OAuth, confirmable, lockable), the built-in approach is perfect for:

• Internal tools
• Admin panels
• MVP applications

6. Propshaft as Default Asset Pipeline

Propshaft replaces Sprockets as the default asset pipeline in Rails 8, eliminating asset compilation complexity. It embraces HTTP/2, works seamlessly with import maps, and speeds up deployments.

# config/application.rb
config.assets.bundler = :propshaft  # Now the default

Benefits:

• No more asset compilation complexity
• Import maps work seamlessly
• Faster deployments
• Simpler debugging

7. Kamal for Zero-Downtime Deployments

Kamal ships with Rails 8 and deploys your app to any VPS with a single command - building Docker images, pushing to your registry, and managing SSL certificates with zero downtime.

# Setup
rails generate kamal:install

# Deploy
kamal deploy

For solo developers and small teams, this is a significant improvement. Teams are replacing complex AWS deployments with simple Kamal configurations deployed to affordable VPS servers.

Migration Tips

If you’re considering upgrading:

1. Start with Dependencies

bundle update rails
bundle update

2. Update Configuration

Rails 8 changes several defaults. Run:

rails app:update

Review and merge configuration changes carefully, especially:

• config/application.rb
• config/environments/*.rb
• config/puma.rb

3. Test Background Jobs

If you’re switching from Sidekiq to Solid Queue:

# Create solid queue tables
rails solid_queue:install:migrations
rails db:migrate

# Update job configurations
# app/jobs/application_job.rb
class ApplicationJob < ActiveJob::Base
  # Solid Queue supports these options natively
  queue_with_priority 10
end

4. Monitor Performance

Use Rails 8’s built-in job monitoring:

/solid_queue/jobs  # Job dashboard

What This Means for Production Applications

Rails 8 reduces infrastructure costs by $30-60/month for typical apps by eliminating Redis and simplifying deployment. Here is how each improvement addresses common production pain points:

1. Reduced Complexity: Fewer services means fewer potential failure points
2. Cost Efficiency: Smaller infrastructure footprint
3. Better Performance: Async queries speed up data-heavy dashboards
4. Easier Compliance: Simpler stack makes security audits easier
5. Faster Iteration: Quick deployments with Kamal mean faster feature delivery

The Bottom Line

Rails 8 proves you don’t need complex build tools, multiple services, or elaborate deployment pipelines to build modern, performant web applications.

For teams building SaaS products, e-commerce platforms, or any data-driven application, Rails 8 offers:

• Simplicity without sacrificing power
• Performance improvements out of the box
• Cost savings through infrastructure consolidation
• Developer productivity through better defaults

What’s Next?

If you’re running Rails 7.x, consider planning your upgrade to Rails 8. Most apps migrate in one to three days, and you see benefits as soon as you drop Redis from your stack.

In the next post, we’ll dive deeper into Hotwire and Turbo patterns for building reactive interfaces without JavaScript frameworks - perfect for complex dashboards and real-time interfaces.

Need help upgrading to Rails 8? I help teams with Rails upgrades, architecture decisions, and adopting the new Solid stack. If you’re planning a migration, reach out at nikita.sinenko@gmail.com.

Further Reading

• Solid Queue in Rails 8: The Complete Production Guide
• Solid Cache in Rails 8: Database-Backed Caching
• Rails 8 Authentication Generator
• How to Deploy Rails 8 Apps with Kamal to a VPS
• Migrating from Sidekiq to Solid Queue
• Rails 8.0 Release Notes
• Kamal Documentation