A Rails Renaissance ?
Ruby on Rails, often simply referred to as Rails, has been a cornerstone of web development since its release in 2005. For years, it dominated as the go-to framework for building dynamic web applications, offering developers unparalleled productivity with its convention-over-configuration philosophy. But as JavaScript frameworks and the rise of Single Page Applications (SPAs) gained traction, Rails lost some of its footing, dismissed in some circles as “past its prime.”
Now, with the release of Rails 8, the framework is seeing a resurgence, and for good reason. It’s addressing modern development challenges with tools and practices that reduce complexity, streamline dependencies, and make thoughtful simplicity achievable.
Rails 8 and the Pursuit of Simplicity
Rails 8 exemplifies what every software developer strives for: simplicity. Complexity isn’t inherently bad—sometimes, it’s necessary. Tradeoffs might be made because of the required complexity of a solution, immovable deadlines, or simply the skills and decisions of the developers writing the code.
In the end, the most important thing is that we deliver and ship code that meets today’s needs while being easily changeable forever. If this sounds familiar, you’ve probably read some of Sandi Metz’s excellent work on object-oriented design. And if you have, you’ll also remember this crucial rule from Sandi:
You can break any rule as long as you can get your pair to agree.
Rails 8 embraces this philosophy, helping developers avoid unnecessary complexity while still providing the tools to manage it when it’s truly needed:
Don’t Want Redis? Use SQLite. Rails now supports SQLite for caching, job queueing, and websocket communications, eliminating the overhead of Redis for smaller projects. It simplifies setups without compromising flexibility.
Don’t Want a PaaS? Use Kamal. Kamal makes it easy to deploy Rails applications to bare-metal servers with minimal configuration, offering an alternative to traditional PaaS solutions while maintaining simplicity and control.
These innovations allow developers to keep their focus on delivering high-quality, maintainable code that balances the tradeoffs of complexity with thoughtful simplicity.
By embracing these tools, Rails 8 allows developers to retain the core benefits of Rails—productivity, clarity, and maintainability—while modernizing workflows to meet current demands.
Revisiting the Core Question: Does This Make Sense?
When Rails first emerged, it solved the complexity of building dynamic web apps by offering sensible defaults and conventions. For the better part of a decade, it was the default choice. But as SPAs became the industry’s new norm, Rails faded into the background. Ask many Rails developers and they'll say they've used it primarily for API applications — no frontends.
SPAs introduced their own set of tradeoffs:
- Increased Complexity: Decoupling frontends and backends creates more interdependencies, doubling the overhead in codebases and deployments.
- Longer Development Cycles: Maintaining two systems often slows delivery, especially for smaller projects or internal tools.
Rails’ resurgence is fueled by developers questioning whether all this complexity is necessary. Are we solving the right problems? Or are we overengineering by default?
The Age of Thoughtful Choices
A recent conversation I had with a colleague highlighted this shift. They were building an internal admin app—no public-facing users, just an interface for employees. Their tech lead proposed building it as a SPA. My question was simple: Why? Why add unnecessary complexity to an application that didn’t need it?
This is the reality of modern development. For years, SPAs and APIs became the default choice without much thought. But with Rails 8, developers are reconsidering their assumptions. They’re asking:
- Does a Rails monolith simplify the solution?
- Does it allow us to deliver on our objectives faster, easier, or better?
- Will we have the flexibility to build our application as it invariably changes over time?
More and more, developers are finding that Rails provides a clear answer: Yes.
Why Rails Matters Today
Rails 8 is not just a return to form—it’s a reminder of what made the framework revolutionary in the first place. It’s opinionated but flexible, conventional yet modern, and powerful without being overcomplicated. It invites developers to embrace thoughtful simplicity, making it easier to focus on what truly matters: building meaningful applications.
This resurgence isn’t just within the Rails community. It’s happening because developers are stepping outside their echo chambers to evaluate tools on their merits, not just trends. They’re rediscovering that Rails allows them to:
- Reduce unnecessary tradeoffs.
- Simplify their workflows.
- Deliver value faster and with less overhead.
For developers and organizations alike, Rails 8 isn’t about nostalgia. It’s about pragmatism—choosing a framework that gets the job done without dragging you into the weeds of complexity.
The Future of Rails
Just as Rails was the answer in 2006, it’s becoming the answer again in 2025. But this time, it’s not about being the default framework—it’s about being the thoughtful choice. Rails’ resurgence proves that good tools don’t die; they adapt, evolve, and thive.
If you’re building a new app or revisiting an old one, ask yourself: Does this make sense? Does it simplify? Does it help you deliver faster, easier, and better? With Rails 8, the answer might just surprise you.