Rails 8.0: Game-Changing Features for Modern Web Development

Rails 8.0 has landed, and it’s bringing some of the most significant improvements we’ve seen in recent years. After spending the last few weeks migrating several production applications to Rails 8, I want to share the features that are truly game-changing for building modern web applications, especially in the FinTech space where I’ve spent most of my career.

The Big Picture

Rails 8.0 isn’t just an incremental update—it represents a fundamental shift in how Rails applications handle real-time interactions, background processing, and deployment. The Rails team has doubled down on the “no-build” approach while making it easier than ever to build fast, interactive applications without leaving the Rails ecosystem.

1. Solid Queue: Built-in Background Jobs

One of the most exciting additions is Solid Queue, a database-backed queuing system that’s now the default in Rails 8. No more Redis dependency for simple background jobs.

Why This Matters

In my FinTech projects, we’ve always needed robust background job processing for:

Payment processing
Report generation
Email notifications
Data synchronization

Previously, this meant adding Redis to your stack. With Solid Queue, your PostgreSQL database handles queuing, making deployments simpler and reducing infrastructure costs.

Real-World 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.

2. Solid Cache: Persistent Caching Without Redis

Following the same philosophy, Solid Cache provides database-backed caching. While I still use Redis for high-traffic applications, Solid Cache is perfect for:

Small to medium applications
Development environments
Applications with moderate caching needs

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

The beauty is in the simplicity—one less service to manage, monitor, and pay for.

3. Enhanced Hotwire Integration

Rails 8 takes Hotwire to the next level with improved Turbo Stream support and better Stimulus integration.

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. Perfect for FinTech dashboards showing:

Live transaction metrics
Account balances
Trading positions

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

4. Async Query Methods

This is a subtle but powerful feature for improving response times.

# 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

In my testing, this reduced dashboard load times by 40-60% for data-heavy pages. The database does the heavy lifting concurrently while your controller continues executing.

5. Better Authentication Scaffolding

Rails 8 includes authentication generators that create secure, bcrypt-based authentication:

rails generate authentication

This creates:

User model with secure password handling
Sessions controller
Authentication concerns
Password reset functionality

For FinTech applications where security is paramount, having a solid authentication foundation from day one is crucial. While we still use Devise for complex scenarios, this built-in approach is perfect for:

Internal tools
Admin panels
MVP applications

6. Propshaft as Default Asset Pipeline

Rails 8 makes Propshaft the default asset pipeline, replacing Sprockets. It’s faster, simpler, and embraces the HTTP/2 era.

# 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

While not technically part of Rails core, Kamal ships with Rails 8 and revolutionizes deployment:

# Setup
rails generate kamal:install

# Deploy
kamal deploy

This single command:

Builds Docker images
Pushes to your registry
Deploys with zero downtime
Manages SSL certificates

For solo developers and small teams, this is transformative. I’ve replaced complex AWS deployments with simple Kamal configurations deployed to affordable VPS servers.

Real-World Migration Experience

I recently migrated a FinTech platform processing $2M+ monthly to Rails 8. Here’s what we gained:

Before Rails 8:

Infrastructure: Rails app + Redis (Sidekiq) + Redis (Cache) + Complex deployment
Monthly costs: ~$450
Deployment time: 15-20 minutes
Dashboard load time: 2.3s average

After Rails 8:

Infrastructure: Rails app + PostgreSQL (with Solid Queue & Cache)
Monthly costs: ~$180
Deployment time: 3-5 minutes (Kamal)
Dashboard load time: 1.4s average (async queries)

Savings: 60% infrastructure cost reduction, 40% faster page loads, 70% faster deployments.

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 FinTech Development

In FinTech, where I’ve spent most of my career, Rails 8’s improvements directly address common pain points:

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

The Bottom Line

Rails 8.0 represents Rails’ commitment to developer happiness while staying relevant in 2025. The framework proves you don’t need complex build tools, multiple services, and elaborate deployment pipelines to build modern, performant web applications.

For teams building SaaS products, FinTech 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, I highly recommend planning your upgrade to Rails 8. The migration is straightforward, and the benefits are immediate.

In my next post, I’ll dive deeper into Hotwire and Turbo patterns for building reactive interfaces without JavaScript frameworks—perfect for those complex FinTech dashboards we all need to build.

Working on a Rails project in Dubai or need help upgrading to Rails 8? I’m available for consulting and contract work. Reach out at nikita.sinenko@gmail.com.