You’ve spent months battling state management libraries. Redux, MobX, Zustand — each one promises salvation but delivers another labyrinth of boilerplate. You’re not alone. We’ve all been there, staring at a wall of middleware and wondering if this is really necessary.
But what if the browser already had everything you needed? What if the solution was hiding in plain sight, three tiny primitives that collectively replace most of your complex toolchain?
The browser has always been capable. We just forgot to look.
I stumbled onto this project after a particularly painful week debugging session persistence across tabs. The source code was almost embarrassingly small. Three primitives: identity, handoff, durable local. Each one trivial on its own. Together, they form a system that handles state persistence and cross-session continuity without a single dependency.
What struck me wasn’t the code — it was the philosophy. Most developers assume scalable web apps require large libraries or managed backends. We’ve been conditioned to reach for the heaviest tool first. But these primitives show that the browser already holds nearly all the pieces. The missing ingredient is just the right abstraction layer.
Three primitives are all you need. No, really.
Identity gives you a stable, user-specific anchor. Handoff lets you move context between sessions or devices. Durable local makes sure nothing disappears when the network drops. That’s it. No Redux stores, no GraphQL subscriptions, no WebSocket reconnect logic. Just the browser’s native capabilities, wired together with surgical precision.
Here’s where it gets uncomfortable. If this works — and it does — then most of our current architecture is overengineered. We’ve been adding layers to compensate for problems that don’t exist. The industry has built a cathedral around a problem that fits in a tool shed.
You think you need a heavy framework? The answer was sitting in your browser all along.
I’m not saying abandon everything. But I am saying we should question our assumptions. Next time you start a web app, ask yourself: Do I really need all that? Or can I just use what’s already here?
This isn’t about minimalism for its own sake. It’s about regaining control. Stripping away unnecessary complexity feels like taking a breath after holding it for years. The primitives are open source, tiny, and composable. They don’t ask you to buy into a worldview. They just work.
Simplicity isn’t naive — it’s the hardest thing to achieve.
So here’s the challenge: try building something with only these primitives. A shopping cart that persists across tabs. A form that survives a lost connection. A user preference that travels with them across devices. If it feels too easy, that’s because it is. The hard part was realizing we didn’t need all the complexity in the first place.
FAQ
Q: Won't I lose features like time-travel debugging or middleware?
A: You lose some convenience, but gain a dramatic reduction in complexity. Most projects don't need those features — and when they do, you can add them selectively without a full framework.
Q: How do these three primitives scale to a large app?
A: They're composable by design. You build exactly the state flow you need, no more. For large apps, the primitives become the foundation, not the ceiling — you layer your own logic on top.
Q: Is this just another 'use localStorage' argument in disguise?
A: No. localStorage is just storage. These primitives add identity (who), handoff (how to pass context), and durability (when to persist). That combination creates a system, not a band-aid.