On the afternoon of 14 November we loaded every live post on this blog twice in Chromium. Once with JavaScript switched off, once with it on. Then we compared 31 pairs.
In 25 of the 31 the text was not quite identical. The difference was always the same sentence: “Swipe sideways to see all of it”. A script adds it under wide diagrams so a phone knows to scroll them, 39 times in all. Nothing else in any article changed.
Google can run it. Its docs still say not to lean on it
Google’s own guide to JavaScript and search describes three steps: crawling, rendering and indexing. A page with a 200 status goes into a rendering queue whether or not it uses JavaScript. A headless Chromium renders it “once Google’s resources allow”, and the guide says the wait can be a few seconds or longer. Google then indexes the rendered result.
It also says that server-side or pre-rendering “is still a great idea”, because it is faster for users and crawlers, and because not every bot can run JavaScript. A second page, on dynamic rendering, calls that older trick a workaround and recommends server-side rendering, static rendering or hydration instead.
We build the blog the third way. Astro turns each post into an HTML file when we deploy, and the file is served as it is. Nothing the article needs is assembled in the visitor’s browser, so there is nothing for Google’s render queue to get wrong. That is the point of building it this way. The test is whether it is actually true.
What we compared
The live sitemap lists 31 posts. Drafts and posts waiting for a client’s written yes are not in it. For each one we loaded the page in Chromium with scripts disabled and again with them enabled. We compared the title, canonical tag, description, robots tag, every heading, every link in the article, the structured data and the full text of the article area.
What differed between scripts off and scripts on, out of 31 posts
Live pages, 14 November 2026. Text differences were only the swipe hint.
Source: zxn.uk's own comparison, 14 November 2026
Every post has exactly one main heading, a canonical tag, a description and structured data in the HTML the server sends. All of it matched after scripts ran.
Outside the article, two things do change. The studio strip along the top swaps a snapshot (“as of 13 Nov, 20:57”) for a live count, and the cookie banner appears. Both are page furniture, not content we need Google to read.
We had been telling ourselves a smaller number
Our own plan file said the blog had “no client JavaScript except search”. That is no longer true. Every post loads ten script files, 45,615 bytes before compression, and the median post’s HTML is 29,532 bytes. The scripts outweigh the page.
Script on every post, in bytes
Before compression, read from the live site on 14 November 2026.
Source: The blog's script files, 14 November 2026
Every one of them is an extra. The menu, the contents list and the diagrams work without them. Google Analytics and Clarity only load after a visitor presses Accept, and we did not measure what they add. We corrected the plan file in the same change as this post.
The point was never zero JavaScript. It is that every byte of it is optional, and we can prove which.
Does it feel fast? A lab answer, with limits
Google’s page experience guide says Core Web Vitals are used by its ranking systems, and also that there is no single page experience signal, that good scores do not guarantee a top position, and that chasing a perfect score for SEO alone may not be the best use of your time. Relevance comes first. We agree, so we are not claiming a ranking boost.
We did check that the scripts cost little. Each of the 31 posts on an emulated Pixel 7, with the processor slowed four times and the network at 1.6 Mbit/s with 150 ms latency:
These are lab numbers from one run each. They are not what real visitors measured, and we have not looked at field data. Google’s third measure, how quickly a page answers a tap, cannot be read from a page load, so we have not tested it.
What this does not prove
We compared two Chromium runs, not Google’s own renderer. Google points to the URL Inspection tool and the Rich Results Test for that view, and we have not run either on these pages. A passing comparison tells us the page says the same thing without scripts. It does not tell us how Google ranks it. It is also the same raw-page view we used when we checked 5,599 UK business homepages, where a title added by script would have counted as missing.
We have filed a task to turn this comparison into a check in our build gate, so a post that needs JavaScript to show its words fails before it ships. The checks a client site already passes before it goes live are in our launch checklist.
Update, 15 November 2026
The next day we applied the same raw-page rule to our staging sites and found a different kind of gap: a noindex header that Google may never read. That is in Our staging sites say noindex. Google may never read it.



