Why I'm Replacing Redux with useOptimistic + React Query
Redux had a fantastic run. For years, it was the default answer to state management in React. If your app grew beyond a few components, Redux inevitably entered the conversation.
But React has changed. The problems we solve today are different from the ones we faced in 2018.
The Real Problem Redux Was Solving
Redux emerged when React lacked mature solutions for data fetching, caching, and complex state synchronization.
- Shared state across components
- Predictable updates
- Centralized business logic
- Debugging via time travel
It was brilliant for its time. But it often became an expensive hammer looking for nails.
Why React Query Changed Everything
A huge percentage of "application state" isn't actually application state—it's server state.
React Query handles that elegantly.
- Automatic caching
- Background refetching
- Retry logic
- Pagination support
- Mutation management
Enter useOptimistic
React's useOptimistic makes UI interactions feel instant.
Users click. The interface updates immediately. The server catches up afterward.
- Faster perceived performance
- Smoother user experience
- Less boilerplate
- Built directly into React
That alone eliminates a surprising amount of Redux ceremony.
What I Gain
- Less code to maintain
- Fewer abstractions
- Simpler mental model
- Better developer experience
- Improved performance
My components are easier to read, easier to test, and much harder to accidentally over-engineer.
What Redux Still Does Better
Redux is not obsolete.
It still shines when you have genuinely complex client-side workflows.
- Offline-first applications
- Sophisticated undo/redo systems
- Heavy local state orchestration
- Large enterprise workflows
The New Stack
For most modern React applications, my stack now looks like this:
- React Query for server state
- useOptimistic for instant UI updates
- Context for lightweight shared state
- Zustand when local complexity grows
That's usually enough.
The Bigger Lesson
Technology evolves, but habits linger.
Many teams still use Redux because they always have—not because they still should.
Good engineering means revisiting assumptions regularly.
Final Thoughts
I'm not abandoning Redux out of fashion. I'm abandoning it because React has finally outgrown many of the reasons we adopted it in the first place.
That is progress.
And frankly, writing less boilerplate feels amazing.
