Source-derived model + registered benchmark

Do soft navigations repay the slow first load?

Single-page apps are sold on a bargain: accept a heavier first load, and get faster in-app navigations back. Until Chrome's soft-navigation API made route changes measurable, that trade was almost impossible to audit. So we did the accounting. Using real RUM-Archive ratios, the break-even is unforgiving — and it does not depend on a benchmark nobody has run yet.

What this is — and what it isn't

Two questions get conflated in the SPA debate. (1) Are soft navigations faster than the equivalent MPA navigation? That needs a matched benchmark — and we specify one in full but do not fake its results. (2) Even when soft navigations are faster, do real sessions contain enough of them to repay the first-load penalty? That one we can answer now, from published data, with a transparent model. This article keeps the two strictly separate: a source-derived amortization result you can reproduce from a one-line equation, plus the registered benchmark needed to close the speed comparison.

The bargain, and the measurement gap that hid it

For years the SPA-versus-MPA argument was fought with one eye closed. The initial document load was visible to every tool; route transitions inside a long-lived JavaScript app were not measured the same way. That asymmetry let both sides be right about different halves of the same session — an advocate could point to snappy later navigations, a critic to a heavy first load with hydration and interaction cost, and neither could settle it. The WICG soft-navigation spec states the gap plainly: existing performance APIs had no way to separate SPA route changes from the initial navigation, and LCP, FCP and CLS were tied to the page lifecycle rather than to later in-app navigations.

Chrome's final soft-navigation origin trial — running Chrome 147 through 149 — closes it. It emits a SoftNavigationEntry when a route change satisfies the soft-navigation criteria (a user interaction, a URL change and a visible paint), and adds a navigationId to largest-contentful-paint, interaction-contentful-paint, event-timing and layout-shift entries so paints, shifts and interactions can be attributed to the specific route that produced them. That is exactly the instrumentation an honest amortization test needs.

A soft navigation as a sequence of pills: user interaction, URL update, route data fetch (TTFB), route paint (interaction-contentful-paint, the route analogue of LCP), route settled, and post-route interaction (INP). A bracket shows the new SoftNavigationEntry and navigationId attributing route-level LCP, CLS and INP across Chrome 147–149. A footer notes that before this, LCP was emitted once for the initial hard load and route changes were invisible to Core Web Vitals.
Figure 1 — A soft navigation, now measurable. The new entry types attribute route-level LCP, CLS and INP to each in-app navigation — the thing Core Web Vitals previously couldn't see.

The real question, then, is not “SPA or MPA?” in the abstract. It is an amortization question: does the cumulative saving from soft navigations exceed the first-load penalty, within the real distribution of session depths?

What the evidence already shows: sessions are shallow

The amortization question has a load-bearing input we can read off published data: how many follow-on navigations a real SPA session actually contains. Alex Russell's 2025 analysis is blunt — multiple independent datasets indicate that sites built as SPAs receive, on average, only about one soft navigation for every hard page load. His RUM Archive charts put numbers on it: of all measured navigations, SPA hard loads and SPA soft navigations occur at nearly the same rate.

Two stacked bars. Desktop: MPA hard loads 45.3%, SPA hard loads 27.6%, SPA soft navigations 27.2%, giving a soft-to-hard ratio of 0.99. Mobile: MPA 50.5%, SPA hard 26.4%, SPA soft 23.1%, a ratio of 0.88. On both devices the SPA soft-navigation share is about equal to the SPA hard-load share.
Figure 2 — The navigation mix in the RUM Archive (Russell, 2025). The SPA soft-navigation share barely matches the SPA hard-load share: ~0.99 soft navs per hard load on desktop, ~0.88 on mobile. The values are read from Russell's published charts; treat them as event-weighted proxies, not user-level session histograms.
0.99soft navs per SPA hard load — desktop
0.88soft navs per SPA hard load — mobile
≈ 1follow-on navigation of amortization room, typical public web
< 1follow-on room on mobile — the harder case

One follow-on navigation is not much room in which to repay a heavy first load. That single fact is what makes the bargain fragile — and it's enough to compute the break-even before anyone runs a speed benchmark.

The break-even model

Let P be the SPA first-load penalty versus the matched MPA; Δ the average saving of a soft navigation versus the equivalent MPA navigation; and K the number of follow-on navigations in the session. The bargain pays off only when the savings repay the penalty:

P  ≤  Σ Δ_i                 the penalty is repaid by the follow-on savings
K  ≥  P / Δ                 follow-on navigations needed (constant Δ)
D* =  1 + P / Δ             break-even session depth (load + follow-ons)

Δ_required = P / r          required per-nav saving, using r ≈ E[follow-on navs]

The last line is the whole argument. If a session contains on average r follow-on navigations, then to repay a penalty P the average soft navigation must save at least P / r. Because r is slightly below one on the public web, the required saving is slightly above the entire penalty — every navigation has to give back more than the first load cost. This turns a vague promise (“routes feel snappier”) into a falsifiable test any team can apply before choosing a framework.

Source-derived results

Plugging Russell's ratios (desktop r = 27.2 ⁄ 27.6 ≈ 0.986; mobile r = 23.1 ⁄ 26.4 = 0.875) into Δ_required = P / r gives the required per-navigation saving for common first-load penalties:

Required average soft-navigation saving to break even, by first-load penalty. Derived from Russell (2025); reproducible from the one-line equation in the pack.
SPA first-load penalty PDesktop break-even (r ≈ 0.986)Mobile break-even (r = 0.875)
250 ms254 ms286 ms
500 ms507 ms571 ms
1,000 ms1,015 ms1,143 ms
1,500 ms1,522 ms1,714 ms
2,000 ms2,029 ms2,286 ms
3,000 ms3,044 ms3,429 ms
A line chart of the soft-navigation saving required to break even (y) against the SPA first-load penalty (x) from 0 to 3000 ms. A dashed naive line marks saving equal to penalty. The desktop line sits just above it (r=0.986) and the mobile line clearly above it (r=0.875). At a 1000 ms penalty the desktop break-even is about 1015 ms and the mobile break-even about 1143 ms.
Figure 3 — Because the average SPA gets fewer than one follow-on navigation, the break-even saving sits above the naïve “saving = penalty” line. A one-second first-load regression needs roughly a one-second saving on the next navigation on desktop, and ~1,143 ms on mobile, just to draw level.

The implication is severe and specific. This is not “SPAs are slow.” It is: at the observed shallow-session ratios, a large first-load penalty must be repaid almost immediately, by a per-navigation saving as big as the penalty itself. Mobile — lower ratio, weaker devices — needs the biggest savings of all, which is precisely where soft-navigation JavaScript work is hardest to make cheap.

Reading the ledger

Think of a session as a ledger that opens in the red by the first-load penalty and is paid down by each follow-on saving. Whether it ever reaches break-even depends on two things the team controls only partly: how big each saving is, and how many navigations the user actually makes.

A cumulative ledger of SPA minus MPA milliseconds over follow-on navigations, with a 1000 ms first-load penalty. A 600 ms-per-navigation saving stays underwater through the first follow-on (still −400 ms) and only crosses break-even at about 1.7 navigations. A 1200 ms saving — larger than the penalty — crosses inside a single navigation. A marker shows the observed public-web room is about one follow-on navigation on desktop and under one on mobile.
Figure 4 — The same 1,000 ms penalty, two saving rates. A “good” 600 ms-per-navigation saving is still 400 ms behind after the one follow-on navigation a typical public-web session provides; only a saving larger than the penalty itself repays within that room. Illustrative.

That picture is the segment story in one image. Where K is small, the bargain needs an implausibly large per-navigation win. Where K is large — a tool people live in for an hour — even modest per-route savings compound into a decisive lead. So the decision is not architectural taste; it is whether your segment supplies enough follow-on navigations to clear your own penalty:

Whether the SPA bargain holds, by segment, given the follow-on navigation depth each segment typically supplies
SegmentTypical follow-on depthThe bargain…
Content, landing, news, docs, SEO acquisitionShallow (≈1 or fewer)rarely holds unless the penalty is tiny
E-commerce category → product → cart journeysShallow–moderateconditional — must be measured, not assumed
Authenticated tools, editors, dashboards, workspacesDeep (many)can hold — confirm with route-level metrics

Why a fast soft-nav TTFB isn't the win

A tempting shortcut is to measure soft-navigation TTFB — the route's data fetch — and declare victory, because it's usually far smaller than a full page load's TTFB. That's a trap. As the soft-navigation TTFB work (Hofman, 2023) and DebugBear's monitoring write-ups document, soft-nav TTFB attribution is genuinely hard: some soft navigations issue no fetch, some issue many candidate fetches, and frameworks differ in how route data is requested. More importantly, a quick data fetch says nothing about when the route actually paints — JavaScript execution, hydration, rendering and layout can all land the visible result late.

So the amortization test's Δ must be a user-perceived quantity: route-level LCP or interaction-contentful-paint, CLS within the route window, and post-navigation INP — not route TTFB. The new navigationId attribution is what makes those route-level metrics collectable in the first place. TTFB is at best a secondary diagnostic.

The MPA baseline moved — the test has to move with it

Even a real soft-navigation saving is measured against a counterfactual, and the honest counterfactual is no longer “an old-fashioned full reload.” Modern multi-page apps get platform help that makes document navigations fast or instant:

A fair benchmark therefore can't compare an SPA only to an unoptimised MPA; it has to include a modern, enhanced MPA arm. Against that baseline the soft-navigation saving Δ shrinks — and the break-even gets harder still, because a prerendered MPA navigation can itself be near-instant.

The benchmark we'd run to close the speed question

The amortization result above stands on published data. The remaining piece — the actual per-navigation speed comparison — needs a controlled study, specified here so it can be executed, audited or disputed. It is deliberately two-armed to defuse the “bad site vs good site” confound:

  1. Arm A · natural matched pairs

    50 SPA journeys and 50 MPA journeys, matched on task class, page-weight band, vertical, content complexity, geography, hosting region and third-party intensity. A “journey” is a scripted multi-step flow (landing → category → detail → form), not a single page.

  2. Arm B · controlled paired builds

    The same journeys built as paired SPA and MPA versions from one content model, API-latency model, component library and visual design — across React, Vue/Nuxt, Angular and a vanilla/platform family — so architecture is the only thing that differs. Each MPA appears in both a baseline and an enhanced (bfcache/speculation/view-transitions) condition.

  3. Route-level instrumentation

    Per navigation: hard-nav TTFB/FCP/LCP/CLS/INP, transfer and JS bytes, main-thread blocking and long tasks; soft-navigation entries; interaction-contentful-paint; and navigationId-keyed attribution for paint, layout-shift and interaction — plus trace markers from route intent to first successful post-route interaction.

  4. The right estimand

    Not average page-load time. The primary estimand is the paired route-level treatment effect — MPA-equivalent navigation minus SPA soft navigation — on route LCP/contentful-paint and post-route INP, reported as median, p75 and p90 with bootstrap intervals on the break-even curve.

  5. Pre-registered discipline

    Paired (not unpaired framework averages), hierarchical (journey in site, site in framework family), with exclusions fixed in advance — navigation failure, route mismatch, missing instrumentation — and a strict rule: never exclude a run for being “slow,” and never fill the journey registry after seeing results. (The registry template ships pre-frozen.)

Threats to validity

The practical decision rule

For a product team choosing an architecture, the gate is four measurements and one inequality:

  1. Measure P

    The SPA first-load penalty against a matched MPA or server-rendered alternative.

  2. Measure Δ — paint, not TTFB

    The route-level soft-navigation saving in LCP/contentful-paint and post-route INP, against the same MPA.

  3. Estimate K by segment

    The real follow-on navigation count for your traffic, from first-party RUM — not the public average.

  4. Apply the gate, twice

    Ship the SPA only where P ≤ E[K] × E[Δ] — then re-run it against an enhanced MPA baseline, because that's the counterfactual your users actually have.

The rule of thumb from the source-derived ratios is uncomfortable for the default: on the public web, desktop SPAs get about one follow-on navigation of repayment room and mobile gets under one. Deep authenticated apps are where the bargain can genuinely pay — and even there, only if route-level paint and interaction metrics confirm it. For content, acquisition and SEO flows, “soft navigations repay the slow first load” should be treated as an unproven promise until measured.

Limitations — read before quoting

  1. The speed saving is not yet measured

    This article derives the break-even from published session ratios; it does not claim a measured Δ. The benchmark above exists precisely to supply it. Treat the result as “how big a saving the bargain requires,” not “how big the saving is.”

  2. Aggregated ratios, not your sessions

    The RUM Archive shares are device-aggregated beacon proportions. Your segment may be deeper (a SaaS editor) or shallower (a landing page). The model is a calculator; K is the input you must supply.

  3. Chart values are image-derived

    The exact 27.6 / 27.2 / 26.4 / 23.1 shares are read from Russell's published charts; the headline ~1:1 ratio is stated in his text. We carry the precise figures as source-derived proxies, not as our own measurement.

  4. A constant-Δ simplification

    The closed form assumes a stable average saving per navigation. Real savings vary by route; the full sensitivity grid in the pack relaxes this across a range of P and Δ.

Data, code & sources

The full pack is published under CC BY 4.0: the source-derived RUM ratios, the compact break-even table, the full amortization sensitivity grid, the deterministic reproduction script, and the pre-frozen 50-pair benchmark registry. The model is a one-line equation — you can check every number.

Browse the artefacts

Key sources

Cite this study

PageSpeedAudit Research (2026). Do soft navigations repay the slow first load?
The SPA bargain under soft-navigation measurement.
https://pagespeedaudit.com/research/do-soft-navigations-repay-the-first-load

@misc{pagespeedaudit2026spabargain,
  title  = {Do soft navigations repay the slow first load? The SPA bargain
            under soft-navigation measurement},
  author = {{PageSpeedAudit Research}},
  year   = {2026},
  url    = {https://pagespeedaudit.com/research/do-soft-navigations-repay-the-first-load},
  note   = {Source-derived break-even model + registered benchmark, CC BY 4.0}
}

Is your SPA's bargain actually paying off?

A PageSpeedAudit report measures your real first-load penalty against a server-rendered counterfactual and — as soft-navigation metrics reach stable Chrome — your route-level savings, so you know whether the trade clears its own break-even for your traffic. Pair it with “The cost of a millisecond” (what the saved time is worth) and “The cost of a kilobyte” (where first-load penalties come from).