Unattributed Navigation Overhead (UNO) Is Underrated – CSS Wizardry

20 August, 2026

• 8 minute learn

Written by Harry Roberts on CSS Wizardry.

View this web page as Markdown.

I need to open this put up by making very very clear that what follows just isn’t my
personal authentic work or analysis. Unattributed Navigation Overhead (UNO) was
coined and delivered to wider consideration by Tim
Vereecke. It’s a kind of concepts
that feels blindingly apparent as soon as somebody has proven it to you: measure the
entire journey to the primary byte, subtract each section the browser can title, and
preserve no matter is left.

I’m truthfully amazed how a lot the net efficiency group has been sleeping on
UNO. Since I started intentionally monitoring it for a consumer, it has modified the way in which
I take a look at Time to First Byte (TTFB) virtually utterly. We hadn’t simply been
lacking slightly element across the edges; in a single occasion, we uncovered roughly
270 ms of navigation time that had beforehand gone totally
unexplained.

What’s left after the subtraction could also be troublesome to attribute — the clue is
within the title in spite of everything — however it’s nonetheless time that our customers paid for. If we
aren’t measuring it, we’re making an attempt to clarify an incomplete TTFB with an
incomplete set of timings.

In step with my need to doc front-end’s lacking
metrics, immediately is UNO’s
flip.

TTFB’s Lacking Time

I’ve written earlier than that TTFB is one thing of a black
field. It’s typically
handled as a synonym for back-end time, nevertheless it covers all the things from the beginning
of the navigation till the primary byte of the ultimate response reaches the
browser. Redirects, DNS, connection setup, TLS, community latency, CDN and server
work, and browser overhead can all sit inside it.

The Chrome Person Expertise Report
(CrUX) can inform us that subject TTFB is
poor, however it will possibly’t decompose that point. It provides us the whole and leaves it
there.

The Navigation Timing
API, alternatively, exposes a lot
extra of the journey. It provides us timestamps for redirects, DNS lookup,
connection setup, the request, and the arrival of the primary response byte. In
precept, that ought to permit us to account for TTFB as a set of smaller, extra
helpful phases.

In observe, these phases typically don’t add again as much as TTFB. There are gaps
between the timestamps, and a few timings are intentionally hidden. The browser
nonetheless consists of all of that point in TTFB; it simply can’t or received’t inform us what the
time was.

UNO is the distinction between the TTFB we skilled and the TTFB we will
attribute.

Including it to charts begins to plug a really apparent hole:

Observe that unexpectedly, beginning 6 August, we’ve got a brand new 270-ish millisecond
UNO entry: 1 / 4 of a second beforehand unexplained. The looks of this
new entry provides us nice perception into hitherto unexplained and untracked time.

You’ll additionally word that, at 610 milliseconds, named redirects truly
account for greater than double that of UNO — does this imply UNO remains to be not as
large a deal as precise redirects…? No. Extra on that later.

How UNO Works

UNO is a residual relatively than a browser-provided metric. We calculate it by
beginning with the complete navigation-to-first-byte length and subtracting the
identified phases: UNO = TTFB − redirect − DNS − connection
− request-to-response-start

The connection section already consists of safe connection setup, so that you don’t want
to subtract TLS a second time. In case your tooling splits TCP and TLS for show,
these two components ought to add again as much as the complete connection section used within the
calculation.

In JavaScript, that is all we have to get UNO:

const navigation = efficiency.getEntriesByType('navigation')[0];
const span = (finish, begin) => Math.max(0, finish - begin);

const uno = Math.max(0, Math.spherical(
  (navigation.responseStart - navigation.startTime) -
  span(navigation.redirectEnd, navigation.redirectStart) -
  span(navigation.domainLookupEnd, navigation.domainLookupStart) -
  span(navigation.connectEnd, navigation.connectStart) -
  span(navigation.responseStart, navigation.requestStart)
));

The end result just isn’t a redirect rely, however a sum of on a regular basis beforehand
unaccounted for. And in a way, it’s nonetheless unaccounted for, it simply now has
a reputation.

Tim’s work and Akamai’s description of the
metric
record a number of issues that will fall into UNO: browser initialisation, delays whereas
unloading the earlier web page, disk or cache entry, browser useful resource competition,
and timings hidden by cross-origin restrictions. In different phrases, UNO just isn’t
one other title for redirect time.

Nevertheless, if a redirect is hidden from Navigation Timing, the time it took nonetheless
has to go someplace. That someplace is UNO.

The Redirects We Can’t See

That is the place the metric turns into significantly revealing. If a navigation
accommodates a cross-origin redirect, Navigation Timing historically units
redirectStart, redirectEnd, and redirectCount to zero. The general TTFB
nonetheless consists of the redirect, however the redirect itself successfully disappears
from the breakdown.

That features totally routine journeys resembling:

• an advert or affiliate hyperlink passing by means of a monitoring supplier;
• a shortened URL resolving to its vacation spot;
• a social community wrapping an outbound hyperlink, or;
• http://instance.com redirecting to https://instance.com.
  • going from http:// to https:// remains to be cross-origin, even when same-site.

The final one is particularly simple to underestimate. A change of scheme means
a change of origin, even when the hostname stays equivalent. What seems to be to us
like a innocent first-party canonicalisation can cross the road that causes
Navigation Timing to begin hiding redirects.

The affect on campaign-heavy websites might be monumental. The folks arriving through
paid search, associates, e-mail, or social media could journey by means of a number of
third events earlier than they attain the touchdown web page. A typical artificial take a look at that
begins straight at that touchdown web page received’t traverse the chain. CrUX will fold
the price into TTFB. Navigation Timing could report a redirect rely of zero.

Our customers skilled the redirects, however our tooling did not seize any of
them.

See the Lacking Redirect for Your self

Here’s a tiny demonstration. Open
https://tinyurl.com/unattributedNavigationOverhead
in a brand new tab, then open DevTools » Console and paste this snippet:

((n) => ({
  redirects: n.redirectCount,
  redirectTime: Math.spherical(n.redirectEnd - n.redirectStart)
}))(efficiency.getEntriesByType('navigation')[0])

The URL redirected you from TinyURL to this website, however you need to see zero
redirects and nil redirect time.

Now, in the identical Console, paste the UNO equal:

((n) => Math.max(0, Math.spherical(
  (n.responseStart - n.startTime) -
  (n.redirectEnd - n.redirectStart) -
  (n.domainLookupEnd - n.domainLookupStart) -
  (n.connectEnd - n.connectStart) -
  (n.responseStart - n.requestStart)
)))(efficiency.getEntriesByType('navigation')[0])

This time you need to get a non-negative quantity. Your end result will differ with
community, browser, cache, and machine situations, nevertheless it captures the a part of
TTFB that the named phases didn’t.

The UNO end result doesn’t let you know that TinyURL carried out one redirect, nor how
many hidden redirects a marketing campaign supplier may need used. It tells you solely
that there was elapsed time the seen Navigation Timing phases didn’t
clarify. Use this as a clue: use UNO to discover a sample, then use DevTools,
managed copy, and marketing campaign or referrer knowledge to establish the trigger.

Now distinction that with the next:

Go to https://www.bbc.com/information/ precisely. Try to be redirected — in a single
hop — to https://www.bbc.com/information (word the lacking coaching slash). Paste
the 2 previous snippets into Console as soon as extra.

Offered you adopted the steps precisely, you need to see a distinction: an
enumerated redirect and its related timing, and a a lot smaller UNO
respectively.

Chrome 151 Makes a Welcome Begin

Traditionally, even a permissive Timing-Enable-Origin response header couldn’t
make cross-origin navigation redirects seen in the way in which it will possibly for
subresources. The header’s present semantics didn’t present the ahead,
destination-based opt-in {that a} navigation chain wants.

Chrome 151 has begun rolling out a cross-origin redirect timing
opt-in.
Redirecting servers can now use Timing-Enable-Origin to allow the vacation spot
origin to measure redirects which can be beneath their management. This is a superb
change, and one I hope different browsers and redirect suppliers undertake shortly.

This received’t make UNO out of date. Each related response in a series must decide
in, present shorteners and marketing campaign platforms received’t essentially all add the
header, and browser assist will nonetheless depart quite a bit invisible to us. Extra
importantly, cross-origin redirects are just one attainable supply of UNO. The
knowledge remains to be invaluable whilst browsers expose extra of the navigation’s
constituent components to builders.

CrUX Can’t Give Us This

CrUX is an awfully helpful RUM dataset, however it isn’t an observability
platform for our personal website. For this explicit job, it stops one degree too
quickly: it will possibly inform us that TTFB is excessive, however not whether or not the issue was DNS,
connection setup, a visual redirect, server response, or 500 ms that none
of these phases account for.

With out the person components, there is no such thing as a significant technique to calculate the
the rest. In CrUX, all of TTFB is successfully unattributed.

That’s the reason UNO is such a compelling argument for a correct actual person monitoring
(RUM) answer. By ‘correct’, I don’t imply that it needs to be costly or belong
to a specific vendor. I imply that it ought to accumulate the browser’s detailed
navigation timings for our precise customers, protect helpful page-view context,
and allow us to question the end result relatively than lowering all the things to at least one percentile.

At minimal, I need to have the ability to:

• chart UNO alongside redirect, DNS, connection, server response, TTFB, and
  Largest Contentful Paint (LCP);
• examine its length and prevalence rely relatively than trying solely at one
  percentile;
• break it down by touchdown web page, marketing campaign, referrer, browser, machine, and
  connection kind;
• see whether or not UNO and TTFB transfer collectively, and;
• isolate consultant web page views for evaluation in DevTools.

That is how an unattributed metric turns into helpful. One worth can inform us that
one thing is lacking; just a few million values with the proper dimensions can inform
us the place to research.

Seven Million Issues We Weren’t Measuring

I not too long ago added UNO to a consumer’s SpeedCurve RUM setup as a result of their LCP is
extremely prone to TTFB regressions. I already knew their TTFB was troublesome;
I didn’t recognize fairly how a lot of it we had by no means accounted for.

Whereas this website clearly appeared to undergo redirects (0.3 s) far more than
UNO (0.04 s), the sheer quantity of UNO they had been incurring utterly
dwarfed the variety of redirects:

Throughout the identical reporting interval, we collected 7,131,737 UNO observations
and solely 166 detectable redirects. I’m not claiming that every one seven million
UNO had been hidden redirects — that might be exactly the error the phrase
unattributed warns us towards — however the disparity reveals how little the
redirect rely alone tells us about actual navigations. However the takeaway right here is
that though named redirects are about 7.5 instances slower than UNO, named
redirects occurred about 99.997672376% much less regularly.

SpeedCurve occurs to be the place I’m accumulating and charting the info, however the
precept is vendor-independent. A business platform, an open-source stack,
or your individual RUM pipeline can all calculate UNO from Navigation Timing. What
issues is retaining sufficient context to phase it.

That is additionally one of many causes I not too long ago constructed LUX
Sidecar. Sidecar augments SpeedCurve’s LUX
beacons with particulars that I need accessible throughout actual investigations,
together with UNO. The small supply and full metric
reference
are public if you wish to see or adapt the implementation.

Begin Measuring What Is Lacking

I don’t suppose UNO ought to stay a distinct segment customized metric. If we monitor TTFB, we
ought to monitor how a lot of it we will’t clarify. In any other case, we danger sending CDN,
platform, database, and utility groups after their few seen milliseconds
whereas a marketing campaign redirect, browser delay, or different unknown consumes tons of
extra.

UNO received’t at all times give us the offender, nevertheless it provides us the lacking magnitude:
proof that the timings in entrance of us should not at all times the entire journey. Correct
RUM then provides us the quantity, context, and segmentation wanted to show that
proof right into a helpful line of enquiry.

Tim was completely proper to make a track and dance about UNO. I’m simply shocked
the remainder of us haven’t been making far more noise!

Often Requested Questions