Performance by design

Fast by construction.
Measured in your browser.

Speed is not a plugin added at the end. On our new system it is decided in advance: pages assembled before anyone visits and kept close to whoever asks, images cut to the screen they land on, video that waits its turn, JavaScript only where someone touches. This page shows the machinery, then measures itself on your device.

See the machinery Measure this page

The figures come from this site and others built on our new system, measured where marked, with the date and the method. Diagrams are illustrative where marked.

01 · The difference

Same page. With and without.

This very page, loaded on a throttled processor over a slow connection. Beside it, the same page without the strategy: photos at full size, fonts from an outside host, all of its code up front.

Measured & modelled · 2026-09-28

With

Measured

This page · as it loads today

Received: 0.0 KB
Requests: 0

First words1.6 s
Largest element2.7 s
Finished4.1 s

Without

Modelled

This page · the strategy removed

Received: 0.0 KB
Requests: 0

First words1.7 s
Largest element51 s
Finished55 s

Bytes receivedsame scale

4 MB8 MB12 MB

Time

The same page loads twice on one clock, with the strategy and without it.

Whole page · desktop · read to the end

Full weight: With: 2.9 MBWithout: 18 MB
Requests: With: 117Without: 125
Outside services: With: 0Without: 3

First load · lab run

Largest element: With: 2.7 sWithout: 51 s

Lab run on this page’s production build, on our new system: cold cache, CPU slowed ×4, 150 ms, 1.6 Mbps. “Without” is modelled from its own measured parts.

How this was measured

An automated Chromium, on a phone-class lab profile: the standard yardstick for comparing loads like for like. Viewport 412×915 at 2.625×, CPU slowed ×4, 150 ms latency, 1.6 Mbps down and 750 kbps up, cache disabled. Three runs; the run with the median largest paint is the one shown. The page is this one, from a production build served on the studio’s own machine, with the network simulated: the first byte recorded is the simulated latency plus the machine’s own, standing in for an edge cache’s, not a measurement of one. Full weight and request counts come from an unthrottled desktop load of the same page, read to the bottom, the same day. “Ready” is the moment the largest element has painted. The clock runs to scale for the first 10 s, where every paint happens, then compresses the remaining 50 s.

The “without” lane is not a second measurement. It is this same page, with four strategies stripped out one at a time and each one’s real cost added back from parts of this page we did measure.

Photos at full size — the 3 photos this page loads (4 requests once responsive sizes are counted), each replaced by the full-size file behind it, the licensed original before it was cut for the web: +15 MB across the page, 9.6 MB of it the backdrop under the title, which is also the largest element.
Fonts from an outside host — this page’s own typefaces, served by Google Fonts instead of by this site: the same files, 354 KB from Google against 354 KB from here. The cost is time: the stylesheet comes from another host, and nothing can paint until it has arrived.
All the code up front — the three pieces of this site that are fetched only when reached for, counted as the code and documents the browser downloads for each: the map library (275 KB), the contact form’s check, its script and the frame it draws (124 KB), and the menu’s palette machine (44 KB). +443 KB added to the first load. The map’s tiles are data a page with no map never fetches, so they stay out.
No edge cache — first byte kept exactly as measured (176 ms): we do not invent a slower origin render to time.

With — Measured checkpoints
Checkpoint	Time	Received
First byte	176 ms	—
First words (FCP)	1.6 s	193 KB
Largest element (LCP)	2.7 s	278 KB
DOM ready	1.4 s	132 KB
Finished loading	4.1 s	700 KB

Without — Modelled checkpoints
Checkpoint	Time	Received
First byte	176 ms	—
First words (FCP)	1.7 s	193 KB
Largest element (LCP)	51 s	10 MB
DOM ready	1.4 s	132 KB
Finished loading	55 s	11 MB

02 · Rendering

The page is ready before anyone asks.

WordPress stays where your team writes, never where visitors wait. Each page is assembled ahead of time and kept at the edge of the network; a saved change is rebuilt in the background.

Illustrative

01 · WordPress

Where your team writes

Waiting for a visitElapsed0 ms

Posts
Post meta
Options
Menus

02 · Build & cache

The site, pre-rendered

Bypassed by every visit

03 · The edge

Near whoever asks

Bypassed by every visit

04 · Visitor

0Visitors sent

A typical WordPress site. Every visit travels all the way to WordPress.

What each pattern answered
Pattern	Last answer	Reached WordPress
Typical WordPress	—	—
Our new system	—	—

Measured 2026-09-28: 10/10 repeat requests answered HIT on 5 sites built on our new system · first byte ≈131 ms

How this was measured

The drawing · illustrative

The visitor, the request and the rebuild are drawn at a readable pace, not to a stopwatch. The typical site’s timer counts that drawing, not a measurement of any real site.

The two figures · measured

Measured from one machine, one request at a time, a second apart, three visits to each of 5 sites built on our new system. 10 of 10 repeat requests were answered from the edge cache (a HIT in the response’s cache header); of the 5 first requests, 4 were, and one was STALE, a refresh already due. The first byte is the wait once the connection is open, the median of 14 HIT answers, ≈131 ms, so it measures the site and not this network.

How pages are rendered

Content pages: static or ISR
Dynamic: only for per-visitor work — forms, sign-in, payment, webhooks

Documented On one of our shop sites, all 14 dynamic routes are such endpoints. No content page is dynamic.

03 · Images

Every image is cut for the screen it lands on.

A photo arrives huge, with the camera’s notes inside. We strip what is private, cap what is excessive and let each screen fetch the size it actually paints.

Measured · 2026-09-28

Step through the story

01 · One photo, three cutsBar: what is left of the original’s weight

The original
3,200 × 2,133 px
JPEG
4.96 MB
Strip
25 KB of camera notes inside25 KB of camera notes removed
4.96 MB4.94 MB
−0.5%
Cap
3,200 px wide3,200 → 2,400 px
4.94 MB245 KB
−95%
Encode
JPEGJPEG → WebP, same pixels
245 KB90 KB
−63%

02 · Which screen?Pixels neededServedBar: share of the largest file servedWeightLighter

Phone390 × 3 = 1,170 px1,200 px18 KB272× lighter
Tablet820 × 2 = 1,640 px1,920 px45 KB112× lighter
Laptop1,440 × 2 = 2,880 px2,400 pxcapped90 KB55× lighter
Large display2,560 × 1 = 2,560 px2,400 pxcapped90 KB55× lighter

Every figure is measured on this photo: its licensed original, then this page’s own image optimizer.

How this was measured

04 · Video

Video that waits its turn.

Every loop is cut in our own tool, the Looper: shorter, lighter, silent, index first. On the page it is fetched only when it is about to be seen, and it pauses when you scroll past.

A · The press

Measured · 2026-09-28

5.01 MB
2.10 MB−58%
3.91 MB−22%
2.75 MB−45%
2.75 MB−45%
2.75 MB−45%
444 KB−91%

Before5.01 MB

A real loop from this site, before the Looper touches it: the raw clip.

Frame: 1280×720
Rate: 30 fps
Length: 20 s
Audio: None
Index: 0.07% in

Weight at each step: Before 5.01 MB, Trim 2.10 MB, Boomerang 3.91 MB, Size 2.75 MB, Silence 2.75 MB, Index first 2.75 MB, Encode 444 KB.

B · The wake

Illustrative · real sizes

Forest lakeAsleep—

Blue motesAsleep—

Violet smokeAsleep—

At load: 0 KB; before any scrolling
Without the strategy: 2.32 MB; everything up front

Fetched so far0 KB

A film wakes one screen ahead, plays while on screen and pauses once passed.

Scroll

Published file, weighed as servedReproduced step, our own re-encode

How this was measured

A. Before and After are the two published files, weighed as served and read for their frame size, rate, length and audio. The index position comes from each file’s top-level atoms: in both, the index sits before the media (bytes 32–3,693 of the source, 32–2,323 of the result). The five steps between are our own re-encode of the same edits, since the Looper keeps no intermediate exports. The bar rises at Boomerang because the length doubles; nothing is smoothed away.

B. The page is a drawing; the sizes are real: Forest lake 776 KB, Blue motes 1.19 MB, Violet smoke 356 KB, still 49.8 KB. All three loops are set up like the forest-lake band on the home page: a still for every device, the film on screens 1,081 px wide and up, never on a connection that saves data. Other loops on the site use other settings. “At load” is what the drawn page fetches before any scrolling: nothing, since no loop lies within a screen of the first one. “Without the strategy” is the three films added together, all fetched up front.

05 · JavaScript

Code only where someone touches.

Words and pictures need no JavaScript to appear. The interactive parts of this site arrive on their own, the moment someone reaches for them.

Measured · 2026-09-28

This page · first visit

HTML36 KB

CSS71 KB

Fonts354 KB

Images & film893 KB

Code245 KB

Whole first visit: 1.6 MB in 35 requests

On request · not in the first visit

The map2.6 MBOn a page that shows one: 275 KB of code, then the tiles it draws.
The form check124 KBThe anti-bot check, on the contact page only.
The menu’s palette44 KBThe drawing on the menu’s Design card: 44 KB of code and styles.

Arrives with this page

Without the strategy

245 KB

688 KB

Computed

of code. The whole first visit: 1.6 MB.

of code on every page, 2.8× as much.

The map’s, the check’s and the menu’s code up front, for every visitor.

A visitor reads this page. Nothing asked yet.

Fetched ahead while idle, on a desktop: 52 KB. The home page and this page in the other language. The menu’s pages wait for a hover or a focus.

Production build · desktop Chromium · cache off · 2026-09-28 · “Without the strategy” computed

How this was measured

Each figure is what the browser received on the wire, headers and body, for one first visit to this page’s production build: desktop Chromium at 1440 × 900, no throttling, nothing cached, nobody signed in; three runs, the middle one kept (the page’s own were identical to the byte). The column counts this page’s own requests only: the browser’s fetch-ahead for other pages was blocked for it and is reported on its own line. “Images & film” includes the loop under the title, which only wide screens fetch once the page has settled.

The map: The map library the privacy page loads when the map comes near the screen, then the style, symbols, fonts and vector tiles it requests as it opens, from an outside tile host. Measured from that page, once it had settled and the map was scrolled into view: the code is the library, the rest is data.
The form check: The anti-bot widget of an outside service, loaded by the contact page and by no other: its script and the frame it draws. Measured with the service’s always-pass test key; a live key can add scripts, so read it as a floor.
The menu’s palette: The drawing on the Expertise menu’s Design card: two scripts and a stylesheet, imported the first time the menu is opened by a hover or a focus. Measured from the home page, once settled: all of it is code and styles.
Without the strategy: This page’s own code plus the three pieces above, all loaded before anyone asks, as if every page carried them: the map library, the form check’s script and frame, the menu’s palette machine, each counted as the code and documents the browser downloads for it. It is an addition, not a separate run, and no other site is involved. The map’s tiles are not added: they are data, and a page with no map never fetches them.
Fetched ahead: The same visit with the browser free to fetch ahead came to 1.7 MB in 49 requests, 52 KB more than the column: 17 KB of code, and the styles and page data of the home page and of this page in the other language, the two links in the header that do not wait for a hover. The pages the menu leads to are fetched when their link is hovered or focused, not before.

What this page weighs: HTML: 36 KB; CSS: 71 KB; Fonts: 354 KB; Images & film: 893 KB; Code: 245 KB; Arrives with this page: 245 KB; Without the strategy: 688 KB; On request · not in the first visit: 0 KB.

06 · The proof

Measured on your device, right now.

Not our lab this time: yours. Your browser keeps a record of how this page loaded and how quickly it answers you. Here it is, against Google’s thresholds.

Live · your device

Reading your browser…

First byteTTFB

Reading…

First wordsFCP

Waiting…

Largest elementLCP

Waiting…

Layout shiftCLS

Reading…

ResponsivenessINP

Click to measure

Frames on this device

The last 120, live

Last: 0.0 ms
Average: 0.0 ms
Dropped: 0

Stress test

The same 60 tiles moved two ways, 5 s each.

Repaint every framewidth + box-shadow

Waiting

Compositor onlytransform + opacity

Waiting

The practice

Speed is a thousand small decisions.

Two sites on the same stack can be seconds apart. The difference is rarely the framework. It is the hero photo left at full size, the request that skips the cache, the loop that plays off screen. We write those decisions down, check them on real devices, and keep them after launch.

What this page shows is our new system, the way we build today. Sites we delivered before it may not include it.

Want a site that is fast on every screen?

Send us your address. We will measure it the way we measure ours.

Discuss your project See the sites we build