Why does everyone use React, and why don't we have to? - The history of the frontend war and the birth of Hotwire
When you hear about web development these days,
You always hear the same thing.
"You should use React for the frontend."
"Everyone is using React these days."
"You can't be a developer if you don't learn React."
But is it really true?
No, to be precise, it is only half true.
It is true that React is a good library.
However, the problem is...
The "situations where React is needed" are really only about 10-20% of the entire web service.
And surprisingly,
Most of the services created by Rails developers
Do not fall within that 10-20%.
1. Many libraries fought bravely until React took its place
There is one fact that beginner developers do not know.
React was not always the 'absolute powerhouse' from the beginning.
Many frameworks and libraries that existed before React
Have now almost disappeared.
AngularJS (dead)
Ember.js (almost dead)
Backbone.js (almost disappeared)
Knockout.js
ExtJS
Meteor frontend layer
jQuery + SPA frameworks
Mithril, Riot, Preact...
The frontend ecosystem
Was a battlefield where over 100 technologies emerged in 10 years, and 98% disappeared.
The reason React survived is significant:
It had a decent structure
It was relatively easy to maintain
Companies adopted it to some extent
However, this means that React will also disappear someday.
Because the essence of frontend technology always remains the same.
2. React is becoming larger and more complex (reality)
Initial React was very simple.
"UI is a function of state."
But what about React now?
React
ReactDOM
JSX
Babel
Webpack
Vite
Next.js
Zustand
Redux
Suspense
Server Components
hydration
client/server boundary
streaming
routing
bundler
compiler-based rendering...
All of these
Have become "essential discussions" within the React ecosystem.
React is no longer just a simple library.
React has become a complex world in itself, and it is getting more difficult every year.
What problems arise from this?
Sharp increase in the barrier to entry for new developers
Maintenance becomes significantly harder if the entire team is not React experts
Initial project speed slows down significantly
The server is simple, but the frontend becomes the core cause of complexity
And this question follows.
"Does my service really need React?"
3. Most SaaS and web services do not need React
The situations where React is needed are mainly two:
Complex SPAs where the UI changes continuously in real-time
(e.g., Figma, Slack (Web), Notion, Trello, etc.)Extra-large projects requiring a large frontend organization and multi-team collaboration
But what about services created by Rails developers?
CRUD services
Dashboards
Blogs
Communities
Data-centric services
Form-centric services
Customer management
Internal tools
SaaS
E-commerce back offices
For these services,
About half of React's features are not necessary.
And when using React,
Development speed actually slows down
And complexity increases significantly.
4. Hotwire, a technology born in this background
Hotwire is a technology stack proposed by the Rails team
And it is based on this philosophy.
"80% of the frontend doesn't need to be as complex as React."
The components of Hotwire are simple:
Turbo (HTML streaming + partial updates)
Stimulus (small JavaScript engine)
Cable + Streams (real-time)
But the core is this.
Updating HTML itself is the fastest, easiest, and most maintainable way in most web services.
Unlike React,
There is no need for processes like state → diff → rendering → hydration...
in Hotwire.
Hotwire follows the philosophy of Rails:
Simplicity
Productivity
Iteration speed
Maintainability
Less code
Developer happiness
And the amazing reality:
When actually implemented, it is 3 times faster than React,
The amount of code is about 1/5,
And bugs are dramatically reduced.
5. Reasons why you don't need to use React - Hotwire has already solved them
Out of the 10 problems React was trying to solve,
Hotwire solves 7-8 of them through a server-centric approach.
For example:
| Problem | React Approach | Hotwire Approach |
|---|---|---|
| UI updates | diff calculation → rendering | Server sends HTML fragments directly |
| State management | Redux/Zustand | Server state = UI state |
| Routing | Frontend router | Optimized page transitions with Turbo |
| Real-time | WebSocket + client rendering | Immediate HTML updates with Turbo Stream |
| SEO | Separate settings | 100% server-side rendering |
| Build | Babel/Webpack/Vite | None (No build!) |
| Complexity | High | Low |
Hotwire dramatically increases the productivity of Rails developers.
6. So, what will happen to React? It will eventually perish. Almost certainly.
Because the history of frontend technology has repeated itself.
- Initially a simple UI library → Gradually becomes feature-rich → Becomes complex → Organizations cannot maintain it → Other technologies emerge → Generational shift occurs
React is also following this path.
In fact, signs of this are already visible.
React Server Components face backlash due to complexity
Performance issues
Next.js leading React rules (React core is no longer independent)
Competitors (Solid, Qwik, Svelte, HTMX, etc.) emerge
Resurgence of "No Build + server-centric web" trend
Currently, developers are saying:
"The web has become too complex these days. We need simplicity again."
This trend has always been correct historically.
Mainframe → PC (regression to simplicity)
SOAP → REST (regression to simplicity)
Era of jQuery chaos → React (regression to simplicity)
Complex SPAs → Hotwire/HTMX (regression to simplicity)
React will eventually disappear. It's just a matter of "when."
Conclusion - We are not choosing technology, but direction
This does not mean not to learn React.
When React is needed, you should definitely use it.
However, most services do not need React. When you use complex technology, speed slows down, and maintenance becomes difficult.
Rails + Hotwire say this:
"The web should be inherently simple.
The server provides HTML, and the browser displays it.
All complexity should be added little by little only when necessary."
This philosophy
Perfectly aligns with the development approach in the AI era.
Especially for beginners, there is a strong reason to use Hotwire.
Fast
Easy
Clear
Fewer bugs
Server state = UI state
No build system
Easy maintenance
Ideal for solo developers
And the most important thing to note:
Hotwire is a technology that will last much longer than React. The philosophy of Rails has stood for 20 years and will not change in the future.