Why

The SPA era solved real problems. The mistake was applying that architecture universally.

What SPAs got right

In 2013, Gmail and Google Maps genuinely required client-side state. A mail client that reloaded the page on every action was unusable. A mapping tool that lost your position on every interaction was broken. The SPA pattern solved a real problem for a specific class of application: one where the interaction model is fundamentally stateful and the latency of a server round-trip is the dominant UX constraint.

That class of application still exists and the SPA pattern remains correct for it.

The universalisation mistake

The error was treating the SPA architecture as the correct default for web development, regardless of whether the application shared any of the requirements that justified it. Food ordering apps. Banking dashboards. Healthcare booking systems. CMS tools. Internal admin panels.

None of these applications require the interaction model of Gmail. All of them were built as if they did.

The compounding cost

When client-side state is the default, a synchronisation problem is introduced that did not previously exist: keeping the client copy of state consistent with the server copy. Solving that problem has generated entire engineering disciplines.

  • State management libraries. Redux, Zustand, Jotai, MobX, Recoil. Each exists to manage complexity that originates from the client holding state.
  • Cache invalidation. React Query, SWR, Apollo. Libraries dedicated to the problem of knowing when the client data is stale.
  • Optimistic updates. Showing the user a predicted outcome before the server confirms it. When the server disagrees, reconciliation is required.
  • Hydration. The server renders HTML, the client re-renders the same HTML in JavaScript, then merges the two. A problem that only exists because the client needs to take ownership of the DOM.
  • Build toolchains. Webpack, Vite, esbuild, Turbopack. Compilers, bundlers, and tree-shakers for a language that runs natively in the browser.

These are not solutions to product problems. They are solutions to the synchronisation problem. They would not exist if the client did not hold state.

The security consequence

When state lives on the client, the client can tamper with it. The classic "isAdmin: true" attack is not a developer error. It is a structural consequence of the architecture. If the client holds a representation of the user permissions, the client can modify that representation.

Server-side validation is often added as a second layer, but the client-side representation persists as an attack surface. Under SAUI, there is no client-side state to tamper with because there is no client-side state.

The security record

Between 2024 and 2026, the major frontend frameworks produced a consistent pattern of critical vulnerabilities. Each traces back to the same architectural layers that client-side state requires.

  • Middleware bypass. Next.js middleware is the standard pattern for route protection: authentication, authorisation, CSP headers. In March 2025, a single HTTP header bypassed it entirely. CVE-2025-29927, CVSS 9.1, gave unauthenticated access to every protected route. The vulnerability existed because the Edge Runtime separates security logic from route handlers by design. The pattern the framework promoted was the attack surface.
  • Serialisation as attack surface. React Server Components introduced a custom binary protocol for streaming server-rendered output. Parsed server-side without sufficient validation, it produced CVE-2025-55182: unauthenticated remote code execution via a single malformed request. CVSS 10.0. Exploited within hours of disclosure. LexisNexis failed to patch for three months and lost 3.9 million records and 53 plaintext cloud credentials.
  • The hydration boundary. Server state serialised into inline HTML so the client can reconstruct it is a persistent XSS vector. React Query (CVE-2024-24558), React Router (CVE-2025-43865), Angular (CVE-2026-32635), and Nuxt (CVE-2024-34343) all demonstrated this. Angular's automatic sanitisation, considered the strongest of any major framework, was bypassed when its i18n and security subsystems interacted.
  • Supply chain. The Shai-Hulud self-replicating npm worm compromised packages across React, Angular, and Vue ecosystems from September 2025 through 2026. Axios, 70 million weekly downloads, was compromised by a North Korean state actor for three hours in March 2026. Polyfill.io, loaded by 384,000 sites, was sold to a threat actor. The average framework application carries 1,000 to 2,000 transitive npm dependencies. Each is a potential vector.

Under SAUI, these attack classes do not apply by construction. There is no hydration boundary: the server renders HTML and sends it. There is no middleware security gate: authorisation runs inside the request handler. There is no custom serialisation protocol. There are no npm dependencies: htmx is a single vendored file and the rest of the stack is Go standard library. These are not mitigations. They are the result of not having the architectural layers that produced the vulnerabilities.

What this is not

This is not an argument that SPAs are bad, that React is wrong, or that JavaScript should be avoided. It is an argument about scope. The SPA pattern is appropriate for applications that share the requirements that justified it. Most applications do not.

SAUI is the web's original model (server renders truth, browser displays it) re-expressed with modern tooling that removes the historical limitations that made SPAs appealing. Slow servers are fast now. Partial page updates are available without a JS framework. Progressive enhancement is achievable without a build step.

See how the architecture works