State management in 2026: the trends I’d actually follow — and the stores I’d stop adding

Ollie Fenwick

Ollie Fenwick

September 18, 2026

State management in 2026: the trends I’d actually follow — and the stores I’d stop adding

I have added Redux to apps that needed a boolean. I have added a second global store because the first one was “for server state” and the new one was “for UI state,” and then I had two places that both thought they owned the selected invoice. In 2026 I still use client state. I just stopped treating a store as the architecture.

The trends I would actually follow are boring if you have been paying attention: keep server data in a cache that understands queries, keep local UI state next to the widget that owns it, and treat URL and form state as first-class. The stores I would stop adding are the ones that exist to recreate those three things with different names.

The split that ended most of my Redux years

Most of what we used to put in a global store was a cache of GET responses plus a few flags. TanStack Query (React Query), SWR, RTK Query, or the load functions in SvelteKit and Remix already do that job. They know stale time, they know a mutation should invalidate a key, they know the user navigated away. A hand-rolled slice that stores invoices: Invoice[] does not know those things unless I reinvent them.

I still reach for Redux Toolkit when I inherit it, or when a desktop-class editor has a real client document — undo, collaboration, a reducer that is the product. I do not reach for it to hold the result of /api/invoices. That is a query. I said that in a frontend bet last week and I will keep saying it: if you need a global store for server data, you wanted a cache.

Signals — Svelte 5 runes, Solid, Angular signals, the various React proposals — are the other trend I would follow. They make “this widget has a count” cheap again. They do not make “the whole app is a signal graph” a good idea. I use signals for local reactivity. I do not build a second database in the client because fine-grained updates are fashionable.

Browser window and a small notebook on a desk, simple UI wireframe

Where I put state now, in order

  1. The URL. Filters, tabs, selected IDs, pagination. If I can share a link and see the same screen, the state is done. nuqs, Remix search params, SvelteKit page stores — pick the helper, do not invent a uiSlice.
  2. The form. React Hook Form, Conform, native form state, Svelte bindings. The draft of an invoice is not a Redux document until I need undo across routes. Most drafts die in a <form>.
  3. The server cache. Query keys. Mutations that invalidate. Optimistic updates only when I can roll back without lying. I have shipped optimistic UI that could not roll back. Users remember that.
  4. Component state. Open/closed, hover, a stepper index. useState, a rune, a signal. If only one widget cares, it is not global.
  5. A small client store. Theme, session hint, a shopping cart that must survive a route. Zustand, a Svelte store, Vue’s pinia for a few keys. Not a second domain model.

Context in React is for injection — theme, a query client, an auth handle — not for high-frequency values. I have seen a context that re-rendered a tree on every keystroke. That is a store I would undo, not a trend I would follow.

Server Components did not kill client state. They shrank the excuse

RSC in Next.js App Router means a lot of data never needs to hydrate into a client store. The page can be HTML that already has the invoices. The client component is the filter box. That is the architecture I want: a thin client, not a store that rehydrates the universe from a script tag.

It also created a new failure: people stuffing client stores because a child needed a value the server already had, and the only path they knew was “lift into Zustand.” Pass a prop. Use a query with the same key. Read a cookie. Do not create useInvoiceStore because the server/client boundary was confusing on Tuesday.

Islands — Astro, a Preact island in a Rails + Hotwire app — make the same point. The island may have its own little store. The document does not. I will follow that. I will not follow “one global store so the island can talk to the header.” The header can be a separate island or a server fragment. Talking is not always a feature.

Stores I would stop adding

Redux for a CRUD dashboard in 2026. Unless you already have it and the team is fluent. The toolkit is fine. The boilerplate-to-value ratio for a settings page is not.

MobX as a default. I have liked MobX. I will not add it to a new React app when signals and query caches exist. If I am in a codebase that is already observable-shaped, I stay.

A second cache next to TanStack Query. I have seen Apollo plus Redux plus localStorage “for speed.” Pick a cache. Persist that cache if you must (the Query persister exists). Do not persist a divergent copy.

XState for every modal. State machines are the right tool for a payment flow with real states: idle, confirming, 3DS, succeeded, failed, retryable. They are the wrong tool for a dropdown. I have used XState and robot and a handwritten reducer. I use the machine when the QA sheet has a matrix. I use a boolean when it does not.

Jotai / Recoil / Signals-as-a-database. Atoms are nice for a canvas. They become a graph only the author understands. If the team cannot draw the atom graph on a whiteboard, it is not simpler than Redux. It is Redux without DevTools your teammates already know.

Developer looking at a network waterfall in browser tools

Backend-driven UI and “the server is the store”

Hotwire, Livewire, HTMX, LiveView — the server holds the state, the client has a socket or a swap. I will follow this for admin tools and for flows that are forms. I will not follow it for an offline-first field app or a Figma-like editor. Those need a client document and a sync story (I have used Yjs; I have also used a boring save button). Trend-chasing means using LiveView for a spreadsheet because a keynote was pretty. I will not.

tRPC and server actions blur the line: the mutation looks local. The state is still on the server. Invalidate the query. Do not also write the result into a slice “to be safe.” Two sources of truth is how a row looks updated until refresh.

What I do in a legacy Redux app instead of a rewrite

I stop adding slices. New server data goes through Query (or RTK Query if we are staying in the toolkit). I delete unused selectors when I touch a file. I move a filter from the store into the URL when I touch that screen. In a year the store is the leftover document, not the world. Rewrites of state layers are how you lose a quarter and keep the bugs.

I also add the DevTools the team will actually open. Redux DevTools, React Query Devtools, the Svelte inspector. A store you cannot see is a store you will duplicate.

Auth, carts, and the other “but this has to be global” cases

Session is the example people use to justify a store on day one. I keep an auth hint in memory — a user id, a name for the header — and I treat the cookie or the httpOnly session as the truth. I refetch /me when a mutation could have changed entitlements. I do not keep a permissions: string[] in Zustand that can drift from the server for an hour. That drift is how a button stays visible after a downgrade.

Carts are more honest as global client state, especially if they must survive a refresh before you have an account. I have used localStorage plus a Zustand persist middleware for that. I have also used a server cart keyed by a signed cookie the moment I needed inventory reservation. When stock is a lie, the cart is not a cosmetic store. It is a backend. Promote it.

Feature flags belong next to the cache or the bootstrap payload, not in a slice that every component imports. I have used GrowthBook and a simple JSON from the server. The client store version always got out of date because someone toggled in the admin and the tab stayed open.

WebSockets are not a store. They are a transport. I apply events onto Query (setQueryData) or onto a document reducer. A socketSlice that accumulates raw messages is how you get a second log of the universe and a memory leak. Subscribe, project, discard.

A 2026 default I would write on a hiring loop whiteboard

If I were starting a product UI tomorrow in React: TanStack Query, URL for shareable state, React Hook Form, Zustand only if I have a cart or a genuine session object that is not the cookie. No Redux. No global event bus. If I were in SvelteKit: load functions plus runes plus a writable store for the rare global. If I were in Vue: Pinia for the rare global, TanStack Query or the official data story, not a Vuex nostalgia tour.

If the product is an editor, I would design a document type first — a JSON structure with a reducer or a CRDT — and I would not pretend Query is enough. That is the exception that still justifies a real client store. Most products are not editors. Most products are lists, forms, and a billing page. Those products have been over-stored for a decade.

I would follow the trend toward less JavaScript on the first paint, more explicit server ownership, and signals for local updates. I would stop adding stores that exist to make a demo look like 2016. The skill in 2026 is not picking a library. It is saying which of the five places a value belongs, and deleting the sixth.

More articles for you