Server State vs Client State
A lot of “state management” pain comes from storing two very different kinds of data in the same place. Separating them is one of the highest-leverage architecture decisions in a frontend app. Tools such as TanStack Query exist because of the server state vs client state split.
1. Definitions
| Client state | Server state | |
|---|---|---|
| Examples | Modal open, selected tab, form draft, theme | User profile, product list, comments |
| Source of truth | The browser | A remote server |
| Ownership | Synchronous, fully owned by the app | Asynchronous, shared with other users, can go stale |
2. Why server state is hard
Server data is a cache of something you do not own. Treating it like client state means re-implementing:
- Loading and error status per request
- Deduplicating identical requests fired by multiple components
- Caching and deciding when data is stale
- Background refetching (on window focus, reconnect, or interval)
- Invalidating related data after a mutation
- Pagination and infinite scroll
- Optimistic updates with rollback on failure
3. Server-state libraries
Tools like TanStack Query, SWR, RTK Query, and Apollo Client handle these concerns with a query key based cache.
const { data, isLoading, error } = useQuery({
queryKey: ['todos', { status }],
queryFn: () => fetchTodos(status),
staleTime: 30_000,
});
const mutation = useMutation({
mutationFn: addTodo,
onSuccess: () => queryClient.invalidateQueries({ queryKey: ['todos'] }),
});
Two components calling the same query key share one request and one cache entry.
4. Stale-while-revalidate
Most of these libraries follow stale-while-revalidate: show cached (possibly stale) data immediately, refetch in the background, then update the UI when fresh data arrives. Users see content instantly instead of a spinner on every navigation.
5. Optimistic updates
For fast-feeling UIs, update the cache before the server confirms, keep a snapshot, and roll back if the request fails.
onMutate: async (newTodo) => {
await queryClient.cancelQueries({ queryKey: ['todos'] });
const previous = queryClient.getQueryData(['todos']);
queryClient.setQueryData(['todos'], old => [...old, newTodo]);
return { previous };
},
onError: (_err, _todo, ctx) => queryClient.setQueryData(['todos'], ctx.previous),
6. What remains for a global store
Once server data lives in a query cache, the remaining global client state is usually small (auth session, theme, a few UI preferences). That is why many apps can drop a heavy global store entirely.
Server State vs Client State: Interview Summary
- Client state is owned and synchronous; server state is a stale-able cache of remote data.
- Use a server-state library for caching, deduping, refetching, and invalidation.
- Keep the global client store small.
