murattunalı.
Reading

Single-page app or multi-page site.

In one the application navigates, in the other the browser; since cross-document transitions, “you need an app for smooth transitions” is no longer true.

For a decade this comparison had an obvious answer: if you wanted smooth transitions, preserved state and fast page changes, you wrote an application. The technical assumption behind that answer has changed. The browser can now animate between two separate documents, and one line of CSS is enough to ask for it. So the comparison is open again.

What the application takes over

A single-page app takes over a job the browser used to do: navigation. What is taken over is more than swapping content — where does focus go, what is the page title, what is announced to a screen reader, what does the back button do, is scroll position restored? All of that has to be written and tested. In return there is a real gain: state stays in memory. A half-filled form, a playing track or an open map survives the navigation.

Where the multi-page side stands today

In a multi-page site every address is its own document and the browser navigates. What is new is that the navigation can also be visually continuous: a cross-document transition animates between the last frame of the old page and the first frame of the new one. The transition is defined in CSS, no JavaScript is required, and in an engine without support the navigation is simply unanimated.

The second difference is measurement: in a multi-page site each navigation is a page load of its own, so field metrics are collected per address. In a single-page app soft navigations fall outside today’s metrics; what you measure is mostly the first load.

A measurement trap: the lab browser is not the real one

When measuring a page that opts into cross-document transitions, be careful: the browser a lab tool starts does not run with the same flags as a visitor’s, and that difference can delay the first frame by seconds. That is exactly what we measured on this site, and the detail has its own post: why Lighthouse says 87 and real Chrome says 98. When deciding, a lab score should not be the only evidence — field data and a real-browser measurement belong on the table too.

How to decide

The question to ask is: “Where does state live?” If a visitor carries state through the session — a document being edited, a long form, an open player — the application side makes that easier. If pages are read independently of each other, the multi-page side gives you less code, a narrower failure surface and the browser’s built-in behaviour for free. This site belongs to the second group, and it sets up its transition without writing an application.

If you want your own site measured and fixed at the source, our Core Web Vitals optimization starts from real-user data and delivers LCP, INP and CLS against a budget.

Criterion

Single-page app

First screen Nothing shows until the app bundle downloads and runs (unless pre-rendered on the server)

Cost of a navigation After the first load, data only

Navigation animation In application code, via a router and an animation layer

State Kept in memory: forms, players, scroll position

Multi-page site (+ cross-document transitions)

First screen HTML from the server is visible in the first frame

Cost of a navigation A document per navigation; caching and prefetching decide the cost

Navigation animation In CSS with `@view-transition`; no application code needed

State The document changes; state that must survive is carried deliberately (URL, storage, server)

Single-page app

Focus, title, back/forward Managed by hand: move focus, set the title, announce the change

Search engines and agents If content is produced on the client, an extra crawling step is required

Failure surface One JavaScript error can stop navigation entirely

Measurement Soft navigations are outside today’s field metrics; what you measure is the first load

Where it fits Interfaces that carry state through a session: dashboards, editors, maps, games

Multi-page site (+ cross-document transitions)

Focus, title, back/forward Done by the browser; anchors and back/forward are built in

Search engines and agents Every address carries its own HTML

Failure surface An error stays within the page; navigation belongs to the browser

Measurement Every navigation is its own page load; lab tools may measure cross-document transitions differently from a real browser

Where it fits Content surfaces: publications, documentation, portfolios, business sites

Single-page app or multi-page site
CriterionSingle-page appMulti-page site (+ cross-document transitions)
First screenNothing shows until the app bundle downloads and runs (unless pre-rendered on the server)HTML from the server is visible in the first frame
Cost of a navigationAfter the first load, data onlyA document per navigation; caching and prefetching decide the cost
Navigation animationIn application code, via a router and an animation layerIn CSS with `@view-transition`; no application code needed
StateKept in memory: forms, players, scroll positionThe document changes; state that must survive is carried deliberately (URL, storage, server)
Focus, title, back/forwardManaged by hand: move focus, set the title, announce the changeDone by the browser; anchors and back/forward are built in
Search engines and agentsIf content is produced on the client, an extra crawling step is requiredEvery address carries its own HTML
Failure surfaceOne JavaScript error can stop navigation entirelyAn error stays within the page; navigation belongs to the browser
MeasurementSoft navigations are outside today’s field metrics; what you measure is the first loadEvery navigation is its own page load; lab tools may measure cross-document transitions differently from a real browser
Where it fitsInterfaces that carry state through a session: dashboards, editors, maps, gamesContent surfaces: publications, documentation, portfolios, business sites

FREQUENTLY ASKED QUESTIONS

Are cross-document transitions available in every browser?

No, and nothing breaks where they are not: the rule is opt-in, and in an engine without support the navigation is simply unanimated. Content, addresses and back/forward behave the same.

Isn’t navigation slow on a multi-page site?

It depends on measurement. If the HTML comes from an edge cache or a prefetch, a navigation costs one document download; on this site the worst measured real-user LCP is 476 milliseconds. Slowness comes from a cache miss and a heavy page, not from the architecture.

Is a single-page app bad for search?

Not bad — expensive: if the content is produced on the client, whoever reads it has to take an extra step, and you cannot assume that step is identical in every engine. A server-rendered app closes most of that gap — but at that point the architecture is already a mixture of the two.

SOURCES