Rails 8: What's New and Why It Matters
A Comprehensive Overview of the Latest Rails Features and How They Benefit Your Business Applications
Rails 8 arrived with a clear mission: make web development simpler, faster, and more self-sufficient. While other frameworks keep adding complexity, Rails continues its tradition of removing it. At DigitalThree, where we've been building Rails applications for 15 years, we see Rails 8 as the most significant release in years—not because it adds flashy features, but because it fundamentally changes what a small team can accomplish.
Let's explore what's new and, more importantly, what it means for your business.
The Philosophy Behind Rails 8
Before diving into features, it's worth understanding the thinking that shaped this release.
David Heinemeier Hansson, Rails' creator, has been vocal about what he calls "the cloud complexity crisis." Modern web development has become entangled with managed services, complex deployment pipelines, and monthly bills that grow faster than revenue. Rails 8 pushes back against this trend.
The goal: a single developer or small team should be able to build, deploy, and operate a world-class web application without depending on a constellation of external services. Not because those services are bad, but because they shouldn't be required.
This philosophy permeates every major Rails 8 feature.
Kamal 2: Deployment Without the Drama
Perhaps the most transformative addition to the Rails ecosystem isn't technically part of Rails itself—it's Kamal, now at version 2 and deeply integrated with Rails 8.
What Kamal Does
Kamal deploys your Rails application to any server with Docker installed. Not Heroku. Not AWS Elastic Beanstalk. Not Kubernetes. Just servers—whether they're $5/month VPS instances or dedicated hardware in a data center.
# Deploy your entire application
kamal setup
kamal deploy
Two commands. Your application is live, running behind a load balancer, with zero-downtime deployments configured automatically.
Why This Matters for Business
Cost reduction is immediate and dramatic. A Rails application that costs $200-500/month on Heroku might run on a $20/month VPS with Kamal. As you scale, the savings compound. We've helped clients reduce hosting costs by 80% or more by moving from platform-as-a-service to Kamal-managed servers.
Vendor independence becomes real. Your deployment configuration lives in your repository. Switching hosting providers means pointing Kamal at different IP addresses. No rewriting deployment pipelines, no learning new platforms, no migration projects.
Control returns to your team. When something goes wrong at 2 AM, you can SSH into your server and investigate directly. No waiting for support tickets, no opaque platform errors, no wondering what's happening inside a black box.
Kamal 2 Improvements
The second version brings significant refinements:
- Kamal Proxy replaces Traefik with a purpose-built, lightweight proxy that handles SSL, load balancing, and zero-downtime deployments
- Asset bridging ensures old assets remain available during deployments, eliminating broken stylesheets during transitions
- Simplified configuration reduces the setup file to essentials while supporting complex multi-server architectures when needed
Solid Cable: WebSockets Without Redis
Real-time features—live notifications, chat, collaborative editing—traditionally required Redis for Action Cable's pub/sub backend. Rails 8 introduces Solid Cable, which uses your existing database instead.
How It Works
Solid Cable stores WebSocket messages in a database table, using efficient polling to deliver them to subscribers. For most applications, the performance difference from Redis is imperceptible, while the operational simplicity is substantial.
# config/cable.yml
production:
adapter: solid_cable
connects_to:
database:
writing: cable
polling_interval: 0.1.seconds
message_retention: 1.day
Business Implications
One less service to manage. Redis requires monitoring, memory tuning, persistence configuration, and failover planning. Solid Cable requires nothing—your database handles everything.
Reduced infrastructure costs. Managed Redis instances aren't cheap. Eliminating this dependency can save $50-200/month immediately.
Simplified development environments. New developers clone the repository and run the application. No installing Redis locally, no Docker Compose files just for development dependencies.
Easier debugging. Messages live in a database table you can query directly. Understanding what's happening with WebSockets becomes a SQL query rather than Redis CLI archaeology.
Solid Cache: Caching in Your Database
Following the same philosophy, Solid Cache stores cached data in your database rather than requiring Redis or Memcached.
The Counterintuitive Logic
Using a database for caching seems backward—isn't the point of caching to avoid database queries? The insight is that modern SSDs make database reads remarkably fast, often fast enough that the operational benefits of eliminating a separate caching layer outweigh the theoretical performance difference.
# config/environments/production.rb
config.cache_store = :solid_cache_store
Performance Characteristics
Solid Cache is designed for durability and simplicity, not raw speed. It excels when:
- Cache entries are relatively large (full HTML fragments, serialized objects)
- Cache persistence across deployments matters
- Operational simplicity is valued over microsecond optimizations
For applications requiring maximum cache performance, Redis remains an option. But many applications will find Solid Cache perfectly adequate while being dramatically simpler to operate.
Practical Benefits
Predictable costs. Database storage is cheap and easy to budget. No surprise bills when cache usage spikes.
No cold cache problem. After deployments, your cache is still there. No performance degradation while caches warm up.
Unified backup strategy. Your cache is backed up with your database. Disaster recovery becomes simpler.
Solid Queue: Background Jobs Without Redis
The pattern continues with Solid Queue, replacing Sidekiq's Redis dependency with database-backed job processing.
Feature Parity with Established Solutions
Solid Queue isn't a minimal implementation. It supports:
- Multiple queues with configurable priorities
- Scheduled jobs and recurring jobs
- Concurrency controls and semaphores
- Job retries with exponential backoff
- Dead job inspection and replay
# config/queue.yml
production:
dispatchers:
- polling_interval: 1
batch_size: 500
workers:
- queues: "*"
threads: 5
processes: 2
Why Businesses Should Care
Background jobs are mission-critical. Email delivery, payment processing, report generation—these can't fail silently. Solid Queue's database foundation means jobs survive server restarts, and failed jobs can be inspected with familiar database tools.
Simpler scaling. Need more job processing capacity? Start more worker processes. No Redis cluster configuration, no memory capacity planning.
Transactional job enqueuing. Jobs can be enqueued within database transactions, ensuring they're only created if the transaction commits. This eliminates an entire class of data consistency bugs.
Authentication Generator: Security Done Right
Rails 8 includes a new authentication generator that creates a complete, production-ready authentication system.
rails generate authentication
This creates:
- User model with secure password handling
- Session model for tracking active sessions
- Login, logout, and password reset flows
- Rate limiting for authentication endpoints
- Secure session management
The End of Authentication Gems?
For years, the Rails community debated "build or buy" for authentication. Gems like Devise offered convenience but added complexity and upgrade challenges. Hand-rolled authentication was simple but easy to get wrong.
The Rails 8 generator offers a middle path: generated code that you own and understand, built on security best practices. No gem dependencies to maintain, no black box authentication logic.
Security Benefits
Rate limiting built-in. Brute force protection isn't an afterthought—it's generated automatically.
Session management by default. Users can see active sessions and revoke them. This feature, often missing from applications, is included from the start.
Password reset done correctly. Secure tokens, expiration handling, and protection against enumeration attacks are all implemented properly.
Propshaft: Simpler Asset Pipeline
Rails 8 defaults to Propshaft, a dramatically simpler asset pipeline than Sprockets.
The Sprockets Problem
Sprockets did everything: compiled CoffeeScript, processed Sass, bundled JavaScript modules, fingerprinted assets. This flexibility came with complexity. Asset compilation errors were notoriously difficult to debug. Build times grew as applications expanded.
Propshaft's Approach
Propshaft does one thing: serves files with digest fingerprints for cache busting. It assumes you'll use separate tools for CSS processing (like cssbundling-rails) and JavaScript bundling (like jsbundling-rails or importmaps).
# Gemfile - Rails 8 default
gem "propshaft"
gem "importmap-rails"
gem "tailwindcss-rails"
```
### Developer Experience Improvements
**Faster asset compilation.** Propshaft simply copies and fingerprints files. No processing pipeline to wait for.
**Debuggable stack.** Each tool does one thing. When something breaks, the cause is clear.
**Modern tool integration.** Use whatever CSS or JavaScript tools you prefer. Propshaft doesn't care.
## Thruster: Production-Ready Serving
Rails 8 includes Thruster, a lightweight proxy that sits in front of Puma in production.
### What Thruster Handles
- **Asset caching:** Serves static files with proper cache headers
- **Compression:** Gzips responses automatically
- **X-Sendfile:** Efficiently serves large files without tying up Ruby processes
### Operational Simplification
Previously, you'd configure Nginx or a CDN for these concerns. Thruster handles them automatically, reducing moving parts in your production stack.
## Script Folder: Organization for Automation
Rails 8 adds a `script/` folder for operational scripts—deployment helpers, database maintenance, one-off tasks.
```
script/
deploy
backup-database
reset-staging
benchmark-queries
Why This Matters
Good operations require automation. Having a conventional location for operational scripts encourages their creation and discovery. New team members know where to look. Documentation becomes easier.
Progressive Web App Support
Rails 8 includes generators for Progressive Web App features:
rails generate pwa
This creates:
- Web manifest for installable applications
- Service worker for offline capability
- Icons and splash screens
Business Applications
Installable web apps. Users can add your application to their home screen without app store distribution.
Offline functionality. Service workers can cache critical resources, allowing limited functionality without network access.
Push notifications. Web push brings mobile-app-style engagement to web applications.
Deprecations and Removals
Rails 8 also cleans house, removing outdated patterns:
- Rails UJS removed: Turbo handles unobtrusive JavaScript now
- Sprockets no longer default: Propshaft takes over
- Ruby 3.1+ required: Modern Ruby features are assumed
These removals reduce maintenance burden and encourage modern practices.
Upgrade Considerations
Moving to Rails 8 is straightforward for most applications. The Rails team maintains excellent upgrade guides, and the process is incremental.
Recommended Approach
- Upgrade to Ruby 3.1+ first if you haven't already
- Update to Rails 7.2 and resolve deprecation warnings
- Upgrade to Rails 8 with minimal changes
- Adopt new features incrementally: Solid Queue, Solid Cache, and Solid Cable can replace existing solutions gradually
What to Watch
- Redis dependencies: If you're using Redis for caching, jobs, and WebSockets, you can eliminate it—but test thoroughly first
- Asset pipeline changes: Propshaft migration may require adjustments if you relied on Sprockets processing
- Authentication: If using Devise or similar, evaluate whether the new generator meets your needs
The Business Case for Rails 8
Let's translate these technical changes into business outcomes.
Reduced Operating Costs
The combination of Kamal deployment and Solid adapters can reduce monthly infrastructure costs by 50-80% for many applications. A typical SaaS application spending $500/month on Heroku plus Redis could run on a $50-100/month VPS.
Faster Time to Market
Less infrastructure complexity means developers spend more time on features. The authentication generator alone saves days of development time. Simpler deployment means faster iteration.
Lower Maintenance Burden
Every eliminated service is a service that won't have outages, won't need security patches, won't require monitoring. The operational simplicity of Rails 8 translates directly to reduced engineering overhead.
Team Scalability
Simpler architectures are easier to learn. New team members become productive faster. Knowledge transfer is straightforward. Your application's success doesn't depend on esoteric infrastructure expertise.
Long-Term Viability
Rails 8 represents a framework that's evolving thoughtfully, not chasing trends. Investments in Rails applications today will continue paying dividends for years. The upgrade path remains clear and manageable.
Conclusion
Rails 8 is a statement about what web development should be. It rejects the notion that modern applications require complex architectures, multiple services, and expensive platforms. It asserts that a well-designed framework can deliver excellent developer experience and production capability with minimal dependencies.
For businesses, this means lower costs, faster development, and simpler operations. For developers, it means focusing on solving business problems rather than managing infrastructure.
The features in Rails 8 aren't flashy. They won't generate breathless blog posts about revolutionary new paradigms. But they will help teams ship better products faster while spending less money. In our experience, that's what actually matters.
Ready to Upgrade or Start Fresh?
At DigitalThree, we've spent 15 years mastering Rails through every major version. We understand not just the technical changes, but their practical implications for real-world applications.
Whether you're considering upgrading an existing Rails application to version 8, starting a new project on the latest Rails, or evaluating whether Rails is right for your next venture, we can help.
Let's discuss your project. Contact DigitalThree today and discover how Rails 8 can reduce your costs, simplify your operations, and accelerate your development.
