Rethinking State Management in React — From a Dev, for Developers.

I’ve been building with React for years, and every time the app grows, so does the complexity around managing state.

Yes, I’ve used Redux Toolkit.
Yes, Zustand is sleek.
But somehow, even in 2025, state management still feels like assembling IKEA furniture with missing screws.

At some point I paused and asked:

What if managing shared state could feel as natural as useState()?

That question sparked a journey — of breaking down there Architecture, understanding what they solve, and what they still miss.

As frontend devs , especially in React, we’ve all had this moment. We reach for state management, and suddenly, a simple feature blows up into a complex web of files and concepts.

Redux Toolkit (RTK) today is certainly better than raw Redux. It streamlines many processes and introduces sensible defaults. But let’s be honest, it still comes with a decent amount of Manual Setup, a learning curve, and an ongoing maintenance burden. While RTK tries hard to abstract this away, Under the hood, architecture still expects:

• A central store
• Slice definitions
• Reducers
• Selectors
• Middleware configuration
• Dispatch-based updates

And let’s talk about the installation. A fresh npm install @reduxjs/toolkit? That's over 6.75 MB unpacked in your node_modules. It pulls in redux, redux-thunk, immer, reselect, and more. While a lot gets tree-shaken in production, that's a chunky dev footprint for simple stuff.

What if State Was Just… Easy? (TypeScript Example)
Imagine state management looking like this:

// 1. Create Shared State (no config file needed!)
createSharedState('theme', 'light');
// 2. Use it anywhere
const [theme, setTheme] = useSharedState<string>('theme');
// 3. Update it (and notify all listeners, instantly)
setTheme('dark');
// 4. Or grab just a slice of it
const isDark = usePicker('theme', t => t === 'dark');

🚀 It just works — no config, no reducers, no slices. Just simple code.

That’s all you need: 4 lines.

👉🏻Want to read more

What Modern State Management Should Have?
Here’s how overwatch-ts Stacks up against Redux Toolkit on key features:

Overwatch-ts : The Minimal, Powerful State System

Overwatch is inspired by the simplicity of Zustland, but it takes a fresh approach from an Architecture Perspective, no more Flux Architecture (Zustland/Redux), it is a modern, TypeScript-first implementation of the Publisher-Subscriber pattern. It’s a super lightweight yet expressive state management library for React.js & Next.js, built on the singleton design pattern. It offers support for global and instance-specific middlewares, immutability, batched updates, and custom event communication — all designed to be used without extensive boilerplate.

All this is delivered with just React hooks. No store setup, no reducers, no ceremony. Just write your components and manage your state intuitively.

Check out overwatch-ts!
Contribute on GitHub:

🔗 GitHub: overwatch-ts

Help Build the Sensible

I truly believe we’re past the age of monolithic, store-centric global state. Modern applications are more component-driven, async-heavy, and UI-dynamic than ever. We need tools that reflect this reality.