Prepared with AI assistance and reviewed for accuracy by Design Den Solutions. Every number below was measured by us on our own live site, on one machine, one browser, one session — our results, not industry averages.
Your brand guidelines say one typeface. Your templates may be serving two.
We audited the eight public pages of our own site (designdensolutions.com) this week, and found that the same navigation rule — .nav-links a { font-weight: 500 }, byte-identical in both templates — renders a different font weight on the homepage than on every inner page. Not a different font family. The same family, different cut, decided by which weights each template happens to request.
This is template drift: the homepage gets a performance pass, the inner pages keep the old head, and nobody re-checks that the two still describe the same brand. Here is the whole audit, the numbers, and the two scripts we used, so you can run it on your own site in about ten minutes.
What the two templates actually request
| Homepage | 7 inner pages | |
|---|---|---|
| Google Fonts request | Plus+Jakarta+Sans:wght@400;600;700 | Plus+Jakarta+Sans:wght@400;500;600;700 |
font-display | optional | swap |
| Font stylesheet loads | 2 (one async media="print" trick, one plain blocking — same URL) | 1, blocking |
preconnect | googleapis.com + gstatic.com | googleapis.com only |
Inline <style> | 2 blocks, 57,014 bytes | 0 |
| External CSS files | 0 (all inline) | 6 |
Three separate drifts in one table:
- The weight sets differ. The homepage never requests 500. The inner pages do.
- The loading strategies differ.
optionalon the homepage,swapeverywhere else. - The homepage's async font-CSS optimization is cancelled by its own duplicate — the second
<link>to the identical URL is render-blocking, so themedia="print" onloadtrick on the first one buys nothing.
The rendered consequence, measured
Both templates style the nav with font-weight: 500. When a requested weight has no loaded face, the CSS font-matching algorithm picks the nearest available one — for 500 with only 400/600/700 present, that is 400. You can prove which face actually rendered without any visual guesswork, using canvas text metrics:
// Run in the console of each page, after document.fonts.ready. const c = document.createElement('canvas').getContext('2d'); const sample = 'Services About Contact Pricing 0123'; const w = f => { c.font = f; return c.measureText(sample).width; }; console.log('400:', w('400 14px "Plus Jakarta Sans"')); console.log('500:', w('500 14px "Plus Jakarta Sans"')); console.log('600:', w('600 14px "Plus Jakarta Sans"')); // If width(500) === width(400), the 500 request is being // served by the 400 face. No 500 face exists on this page. Our results, same browser, same session, same sample string:
| Page | 400 | 500 | 600 | 500 face loaded? |
|---|---|---|---|---|
| index.html | 240.90 px | 240.90 px | 245.15 px | no |
| branding.html | 240.90 px | 243.07 px | 245.15 px | yes |
On the homepage, 500 and 400 are the same pixels. On branding.html, 500 is its own face, 2.18 px wider on a 34-character sample (~0.9%). Width is just the proxy — the visible difference is stroke weight: the nav is literally lighter on the homepage than on the pages it links to. document.fonts confirms it: three loaded weights on the homepage (400/600/700), four on the inner pages.
One caution if you run this: document.fonts.check('500 14px "Plus Jakarta Sans"') returned true on the homepage even though no 500 face exists — check() runs the same matching algorithm, so it reports the matched face, not the requested one. Canvas width equality is the honest test.
The slower-network divergence (spec-derived, not measured)
font-display: optional gives the font roughly a 100 ms block period; if it misses that window, the fallback renders for the rest of that page view (the font may still download for the next navigation). swap shows the fallback briefly, then swaps the brand font in whenever it arrives.
So on a cold cache over a slow line, a first-time visitor can read the entire homepage in system-ui, click through, and watch the brand typeface appear on the service page. One brand, two heads — mid-session. We did not measure this on a throttled connection; it follows from the two font-display values we did verify in the served HTML. Treat it as a mechanism, not a benchmark.
The audit script
Fetch your pages and diff their font requests. This is the actual script we ran (Node, no dependencies):
const pages = ['index', 'about', 'services', 'contact']; // your paths const base = 'https://www.example.com/'; for (const p of pages) { const html = await (await fetch(base + p + '.html')).text(); const links = [...html.matchAll(/<link\b[^>]*>/gi)].map(m => m[0]); const font = links.filter(l => /fonts\.googleapis/.test(l)); console.log(p, { requests: font.map(l => (l.match(/family=([^&"']+)/) || [])[1]), display: [...new Set([...html.matchAll(/display=(\w+)/g)].map(m => m[1]))], duplicateFontLinks: font.length - new Set(font).size, preconnects: links.filter(l => /preconnect/.test(l)) .map(l => (l.match(/href=["']([^"']+)/) || [])[1]), }); } Then grep your CSS for every font-weight value and diff that set against each template's requested weights. Any weight in the CSS but not in the request is a silent substitution waiting to happen.
What we fixed vs what we're reporting
To be clear about scope: this article is the audit, not the fix. The fixes are queued for our own deployment review — align the weight sets, pick one font-display strategy per brand decision (not per template accident), delete the duplicate font link, and add the gstatic preconnect where fonts actually download from. We also found a dead rule declaring Instrument Serif for a component that no longer renders it — the font is never requested, and canvas metrics show the name resolves to Times New Roman. Dead type declarations are drift too; they just haven't bitten anyone yet.
What we are not claiming
- No field data, no user-perception study, no conversion claim. One machine, one browser, one session.
- The weight difference is measured in canvas text width, not visually assessed for "noticeability".
- The slow-network behaviour is derived from the CSS spec and the observed
font-displayvalues, not throttled measurements. - This is our own site and our own audit — a self-published referral placement, not third-party coverage.
If your brand guidelines specify a typeface and weights, your templates should be testable against them — the same way you'd test a logo at six sizes. Typography is part of the brand system, and drift is a bug, not a style choice.
Design Den Solutions builds brand systems and the websites that carry them — logo lockups, colour and typography systems, and mobile-first web development. Service details: Branding & Identity at Design Den Solutions · www.designdensolutions.com · +91 98721 90965
