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.

Ready in 0.4 s. Normal connection · measured live · 2026‑11‑12

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.

On a normal connection, this very page is ready in a fraction of a second. Here it is under stress, on a slowed processor over a slow connection, beside the same page without the strategy: photos at full size, fonts from an outside host, all of its code up front.

Stress test · measured & modelled

With

Measured

This page · under stress

Received
0.0 KB
Requests
1
  1. First words2.2 s
  2. Largest element2.2 s
  3. Finished2.8 s

Without

Modelled

This page · under stress, strategy removed

Received
0.0 KB
Requests
1
  1. First words2.7 s
  2. Largest element2.7 s
  3. Finished4.3 s
Bytes receivedsame scale
0.4 MB0.8 MB

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

Normal connection · measured live

First byte
Live: 155 ms
Largest element
Live: 0.4 s
Finished
Live: 0.5 s

Whole page · desktop · read to the end

Full weight
With: 551 KBWithout: 5.6 MB
Requests
With: 41Without: 48
Outside services
With: 0Without: 2

Stress test

Largest element
With: 2.2 sWithout: 2.7 s

Normal connection: live, cold cache, median of 9 runs, 2026‑11‑12. Stress test: lab, 2026‑11‑12, cold cache, CPU slowed ×4, 150 ms, 1.6 Mbps; “Without” is modelled.

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, as it is served live, through that simulated connection: the first byte recorded is the real answer plus the simulated latency. 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: here that is the opening’s text, which paints with the first words. The clock runs to scale from start to finish. The normal-connection figures are a separate reading: this page as it is served live, in a desktop Chromium at 1440×900 with nothing slowed, a fresh browser and an empty cache for each of nine runs, from the studio’s own connection; the run with the median largest paint is the one shown.

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 site we did measure.

  • Photos at full size — the 2 images this page loads (3 requests), each replaced by the full-size file behind it, before it was cut for the web: +5.0 MB across the page. The largest element here is text, so full-size files add weight and leave the first paint almost where it is.
  • Fonts from an outside host — this page’s own typefaces, served by Google Fonts instead of by this site: the same files, 106 KB from Google against 106 KB from here. Timed both ways on this profile, the first paint did not move: the outside stylesheet lands before this page’s own. What this adds is an outside host on every visit.
  • All the code up front — the code and styles of the menu’s drawings, the one piece of this site left out of the first load that every page would carry, since every page has the menu: +80 KB after the first load, counted as the code and documents the browser downloads for it. Their logos are data a page without them never fetches, so they stay out. The map library and the contact form’s check stay out too: the first comes only with the page that shows the map, the second only with the pages that have a form. Then what this page holds back itself: the code of its interactive sections until they are near the screen, and the scenes and styles of other pages. We served this page both ways from one test server, nine runs each: with those 133 KB in its first load, the first paint came 0.4 s later on this profile.
  • No edge cache — first byte kept exactly as measured (255 ms): we do not invent a slower origin render to time.
With — Measured checkpoints
CheckpointTimeReceived
First byte255 ms—
First words (FCP)2.2 s296 KB
Largest element (LCP)2.2 s296 KB
DOM ready2.3 s308 KB
Finished loading2.8 s439 KB
Without — Modelled checkpoints
CheckpointTimeReceived
First byte255 ms—
First words (FCP)2.7 s358 KB
Largest element (LCP)2.7 s358 KB
DOM ready2.7 s358 KB
Finished loading4.3 s706 KB

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

  1. Posts
  2. Post meta
  3. Options
  4. 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
PatternLast answerReached 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

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

  1. Storm clouds moving through dark alpine peaks

    The original

    3,200 × 2,133 px

    JPEG

    4.96 MB

  2. Strip

    25 KB of camera notes inside25 KB of camera notes removed

    4.96 MB4.94 MB

    −0.5%
  3. Cap

    3,200 px wide3,200 → 2,400 px

    4.94 MB245 KB

    −95%
  4. 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
  1. 5.01 MB
  2. 2.10 MB−58%
  3. 3.91 MB−22%
  4. 2.75 MB−45%
  5. 2.75 MB−45%
  6. 2.75 MB−45%
  7. 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.

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-11-12

This page · first visit

HTML48 KB
CSS105 KB
Fonts106 KB
Images5.2 KB
Code239 KB

Whole first visit: 503 KB in 35 requests

On request · not in the first visit
  • The map622 KBOn a page that shows one: 280 KB of code, then the tiles it draws.
  • The form check1.9 MBThe anti-bot check, on the contact and careers pages only.
  • The menu’s drawings125 KBThe drawings on the menu’s cards: 80 KB of code and styles, then their logos.

Arrives with this page

Without the strategy

239 KB

319 KB

Computed

of code. The whole first visit: 503 KB.

of code on every page, 1.3× as much.

The code of the menu’s drawings up front, for every visitor.

A visitor reads this page. Nothing asked yet.

Fetched ahead while idle: nothing. The pages behind the header and the menu wait for a hover or a focus.

Live page · desktop Chromium · cache off · 2026-11-12 · “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 as it is served live: desktop Chromium at 1440 × 900, no throttling, nothing cached, nobody signed in, nothing scrolled, the mouse not moved; three runs, the middle one kept. The column counts this page’s own requests only.

The map
The map library the privacy page loads when the map comes near the screen, then the style, symbols, fonts and vector tiles of the map at rest, from an outside tile host. Measured from that page in English, once it had settled and the map was scrolled into view: the code is the library, the rest is data, and moving the map fetches more.
The form check
The anti-bot widget of an outside service, loaded by the contact and careers pages and by no other: its script, the frame it draws and the check that frame runs. Measured on the live contact page, in an automated browser. The service decides what it sends each visitor, so read it as one visit’s figure, not a fixed size: a person may be sent less.
The menu’s drawings
The drawings on the Expertise menu’s cards: two scripts and a stylesheet on the first mouse move, two more scripts and a stylesheet the first time the menu opens, then the small logos they show. Measured from this page, once settled: the scripts and styles are the code, the logos are data.
Without the strategy
This page’s own code plus the code and styles of the menu’s drawings, loaded before anyone asks: every page has the menu, so every page would carry them. They are counted as the code and documents the browser downloads for them; their logos are data and are not added. It is an addition, not a separate run, and no other site is involved. The map library and the form check are not added either: the first comes only with the page that shows the map, the second only with the contact and careers pages, the two that have a form.
Fetched ahead
The same visit with the browser’s fetch-ahead blocked and with it free came to the same requests: this page asks for no other page on its own, and reading it to the end adds none. The pages behind the header’s links and the menu are fetched when their link is hovered or focused, not before.

What this page weighs: HTML: 48 KB; CSS: 105 KB; Fonts: 106 KB; Images: 5.2 KB; Code: 239 KB; Arrives with this page: 239 KB; Without the strategy: 319 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

Covers
This page
Requests
—
Network
—
Cache
—
JavaScript
—
Outside hosts
—
How this was measured

Every figure here is read from an API your browser already exposes to any page. None of it is sent anywhere; this page has no analytics of its own.

Navigation Timing
First byte: responseStart on the page’s navigation entry, less activationStart if the page was prerendered.
Paint Timing
First words: the first-contentful-paint entry, by the same rule.
Largest Contentful Paint
Largest element: the latest candidate. It is called final when you interact with the page or leave the tab, which is when a page stops growing a “largest” element, or when the load has finished and about three seconds pass without a new one; a later candidate reopens that. A candidate stamped after the tab was first hidden is ignored.
Visibility State
A tab loaded in the background is not painted until it is shown, so its first paint carries the whole wait. Like Google’s web-vitals library, we ignore paint records from the moment the page was first hidden, and say so instead of showing a “load” of hours. Chrome keeps that history; other browsers only tell us whether the tab was hidden when this reading began.
Layout Instability
Layout shift: every shift not caused by your own input, folded into Google’s session windows (a new window opens after a 1 s gap or past 5 s), the same definition Chrome reports.
Event Timing
Responsiveness: the slowest of your interactions so far, once you have made one. With only a few interactions on a page like this, that is close to Google’s own 98th-percentile estimate. Interactions faster than 16 ms are below what the API reports.
Resource Timing
Requests, bytes and outside hosts: every request this page has made, as the browser discloses it (up to its list of 250). Bytes are split into what crossed the network and what the browser served from its own copy, which is most of a reload; JavaScript counts both. A file from another host may keep its size private: it counts as a request but not in the bytes, and an asterisk marks the totals that leave one out.
Changing pages
This site changes pages without reloading. The browser keeps one navigation record, first paint and largest paint per visit: those of the page where the visit began. When that is not this page we name it and offer to reload this one. Layout shift and responsiveness always cover the whole visit.
Back/forward cache
A page restored from that cache was not loaded. We say so, with the wait until its second painted frame, instead of showing stale load numbers.
requestAnimationFrame
Frame times: the gap between one paint and the next, on your own device, right now. The refresh rate is read from the quick end of those gaps and snapped to the nearest common rate; a frame counts as dropped when it took more than one and a half refresh intervals.
The dials
Each dial is cut at Google’s thresholds: good fills half of the arc, needs improvement runs to 80%, poor is the rest. Inside the good zone the needle follows the square root of the reading, so a fast one is not lost against the left edge. The figure beside the dial is exact.
Excellent
Our own mark, not Google’s, whose scale stops at good: a reading at or under half of Google’s good threshold (first byte 400 ms, first words 0.9 s, largest element 1.25 s, layout shift 0.05, responsiveness 100 ms). It is the brighter start of each green zone.

Nothing here is sent anywhere. It is a reading, not a report.

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.