Real visits
Judged on 3 in 4 visits
Google’s speed targets (Core Web Vitals) pass when 3 in 4 visits are good, over 28 days of Chrome data. We also track each page type, device and release.
Service 01 of 10Technology & Intelligence
Websites, online shops and apps that load fast, are easy to use and stay secure. We build for new and growing businesses and enterprises. We check speed on every change, before and after launch.
Illustration: the same “Your platform” product page on a desktop, a tablet and a phone. Each is laid out for its screen. Speed from real visits is good on all three. Desktop: main content in 1.2 seconds, taps answered in 60 milliseconds, layout shift 0.01. Tablet: 1.7 seconds, 110 milliseconds, 0.02. Mid-range Android phone on 4G: 1.9 seconds, 140 milliseconds, 0.04. Values are illustrative.
01 · After launchPhone load time · 3 in 4 visits · first 90 days
A site can score 98/100 on a fast laptop. Then tracking tags, videos and chat tools slow it down. We judge it on real visits, daily.
p75 LCPMain content load time, seconds, per day
Line chart, illustrative, of phone load time for 3 in 4 visits. In the 90 days after launch, an unmanaged site rises from 2.2 to 5.1 seconds. It steps up at each event below and ends in the poor band. A speed-checked site stays between 2.1 and 2.5 seconds, in the good band.
Unmanaged5.1 sPoor
Speed-checked2.1 sGood
1Day 12
Marketing tags added
Unmanaged +0.5 s
Loaded after consent · +0.1 s
2Day 34
Big autoplay video
Unmanaged +0.9 s
Blocked by the budget · still image shown
3Day 58
A/B test script in the browser
Unmanaged +0.5 s
Run on the server · no browser script
4Day 77
Chat widget on every page
Unmanaged +0.5 s
Loads when first used


Real visits
Google’s speed targets (Core Web Vitals) pass when 3 in 4 visits are good, over 28 days of Chrome data. We also track each page type, device and release.
Response to taps
On 12 March 2024, Google began timing every tap and click in a visit (INP). Heavy code now shows up. Good is 200 ms or less.
Speed budget
Automatic speed tests (Lighthouse CI) run on every proposed change. A change over budget cannot go in until it is shrunk, delayed or removed. Alerts watch live speed after each release.
02 · What we make6 kinds of build · one set of checks
Each starts with the same base: a shared kit of buttons and styles, speed budgets, accessibility checks and live monitoring.
01
Fast sites with a website editor (CMS) your team can use, with previews before you publish. They stay fast as you add pages.
02
Customer portals, dashboards and subscription software. Each user sees only their own data, and it works on a weak signal.
03
Separate iPhone and Android apps, or one shared app. We choose by device features, offline use and team skills.
04
Shopify or custom shops, with search, product pages and checkout that stay fast on cheap phones.
05
Web apps that install like an app and save work offline, so field teams keep working.
06
One kit of buttons, screens and styles for web and mobile, tested for accessibility on every change.
03 · Speed demoTry it · illustrative model
Pick a device and a connection. Then switch on the fixes we use in every build. Watch the page load, its scores against Google’s targets and what each fix saves.
Device type
Network
Speed fixes6 of 6 on
Filmstrip · one frame every 0.6 s
LCPLargest Contentful Paint
2.1 sGood
INPInteraction to Next Paint
160 msGood
CLSCumulative Layout Shift
0.03Good
Page weight0.93 MB
Server wait (TTFB)590 ms
First Contentful Paint1.2 s
Est. gCO2e per view0.20 g
Google speed check · real-visit spread
Passedall three at p75 must be good
What changednewest first
An illustrative model, not a measurement of any site. Limits are Google’s targets (Core Web Vitals) for 3 in 4 visits. Good is LCP ≤ 2.5 s, INP ≤ 200 ms and CLS ≤ 0.1. Poor is above 4 s, 500 ms and 0.25. A page passes when all 3 are good. We assume loads spread log-normally around each value. Emissions use the Sustainable Web Design method for a first, uncached view. It assumes 0.494 kWh per gigabyte and a global-average 442 gCO2e per kilowatt-hour. That is about 218 gCO2e per gigabyte (1 GB = 1,000,000 KB). Section 08 uses the same 2 numbers.
04 · Our toolsOne page load · phone · 4G · time limit per step
Each tool does one step of loading a page, within a time limit. Pick a step to see why we chose it. The timeline below follows one page from tap to screen.
Diagram, illustrative: the path of one page request. It goes from the device to a nearby server, the main server, links to other systems (APIs) and the database. Each step reports to monitoring. Limits in milliseconds: device 150, nearby server 30, main server 180 and APIs 120 for 19 in 20 requests. The database gets 40 per lookup and monitoring 5.
01≤ 150 ms to be usable
We send the least code that does the job. Astro or Next.js, by how much a page must do. Flutter or React Native when one app serves both stores. Swift and Kotlin for apps that lean on the camera or sensors.
How we keep to the limitCode-size limit per page · code only where people tap · tap speed checked on live visits
Tools we use at this step
02≤ 30 ms nearby
Copies of pages and files sit close to your users, so most visits never reach your main server. Each release refreshes only what changed. We use Cloudflare or Vercel, or Fastly or Akamai if you already pay for one.
How we keep to the limitShare of visits served nearby · old copy shown while refreshing · new name per file version
Tools we use at this step
03≤ 180 ms to start sending
The page arrives ready to show. Its frame is sent before the data, so fonts and the main image load while the product details are fetched. We use Next.js for full apps and Astro for simple content sites.
How we keep to the limitBuild time per page type, 19 in 20 · sent in parts by default · no call chains in the browser
Tools we use at this step
04≤ 120 ms for 19 in 20
APIs link the screens to every system behind them, in one agreed format (GraphQL or OpenAPI). Calls are combined and briefly saved, so a busy product page needs one round trip. Your site editor or Shopify uses the same links.
How we keep to the limitFormat tested per change · repeat queries blocked · calls combined
Tools we use at this step
05≤ 40 ms a lookup, 19 in 20
PostgreSQL, set up for the lookups your app makes, with Redis for log-ins, baskets and popular data. Every lookup has a time limit and an alert. A table that grows tenfold is caught before customers notice.
How we keep to the limitSlow lookups reviewed every cycle · data changes tested on a copy of live data
Tools we use at this step
06≤ 5 ms extra
OpenTelemetry tags every step with one ID, so we can follow a slow page from tap to database. Sentry links each error to the release that caused it. Datadog records speed on live visits. Sampling keeps the cost under 5 milliseconds.
How we keep to the limitOne ID across all steps · release named on every error · alerts per page type for 3 in 4 visits
Tools we use at this step
One request, tracedfirst visit · mid-range Android · 4G · trace-id 7f3a…c21e
First byte 120 msHTML complete 212 msLCP 1.9 sIllustrative
Timeline of one page request, illustrative. Connecting takes the first 38 milliseconds. The nearby server has no copy yet at 52. The page frame is sent by 120 milliseconds. Three API calls run side by side until 165, and the database answers by 96. The page is complete at 212 milliseconds. The main content shows at 1.9 seconds. The timeline is saved in the background.
Before release
Built, tested and speed-checked automatically, so only code that passes every check goes live.
05 · Everyday use4 places · 4 needs
Your users are rarely at a desk on fast Wi-Fi. We design and test for 4 everyday places, and set what each needs before we write code.

Place 01 · Warehouse floor
Gloves, glare and signal that drops behind the shelves.
What it needs

Place 03 · Operations desk
2 monitors, dense tables and a keyboard that rarely leaves the hand.
What it needs

Place 02 · Commute
One hand, one thumb and a network that comes and goes between stations.
What it needs

Place 04 · Bus stop
Bifocals, cold hands and the text zoomed to 200%.
What it needs
06 · Quality checks7 checks · set as numbers · run on every change
Each check is a written limit kept with your code: kilobytes, seconds or number of failures. Each change is tested with the latest code. Pick a change to see how it did.
Illustrative changesIllustration of a queue holding three proposed changes against seven written limits. Change 412, gallery zoom and AVIF hero images, is first in line and meets every limit. Change 414, filters on the listing page, sends 318 kilobytes of JavaScript against a 250 kilobyte limit. The queue stops there. Change 415, a library update, passes every check but waits third. The other six limits: zero accessibility failures, zero unreviewed screen changes and zero failing or flaky tests of 1,380. Also zero critical or high security warnings and zero broken redirects of 1,240 rules. The app must start in 1.8 seconds for 3 in 4 launches on a Pixel 6a. AI suggests loading the filter panel only when opened. That brings 414 down to 226 kilobytes and frees the queue. A person commits it.
Change queue · your-platform / web held at #414
The queue tests each change on top of the ones ahead of it. So two changes that each pass alone cannot break the live code together.
#412Engineer · 3 commits · +412 −96
A code owner approved it at 14:02. The queue adds the latest code and reruns every check, so it goes in exactly as tested.
#414Engineer · 7 commits · +1,204 −212
The listing page sends 318 KB of code against a 250 KB limit. Nothing behind it goes in until it meets the limit or is dropped.
#415Opened by AI · 1 commit · +18 −18
Every check passes, but it waits its turn. It goes in once #414 clears or an engineer takes #414 out.
What WCAG 2.2 adds to the accessibility check
| Rule | Level | What it means in practice |
|---|---|---|
| 2.4.11Focus Not Obscured (Minimum) | AA | Fixed headers and cookie bars never hide the selected item. |
| 2.5.7Dragging Movements | AA | Every drag has a click or keyboard alternative. |
| 2.5.8Target Size (Minimum) | AA | Buttons at least 24 × 24 px. We build to 44 px on touch. |
| 3.2.6Consistent Help | A | Help and contact sit in the same place on every screen. |
| 3.3.7Redundant Entry | A | Nothing already entered is asked for twice in a flow. |
| 3.3.8Accessible Authentication (Minimum) | AA | Sign-in never relies on memory or copying. |
Where the limits come from
Each limit comes from a published standard. Size and time limits follow Google’s targets for 3 in 4 visits. Accessibility follows WCAG 2.2 AA. Security follows OWASP ASVS Level 2 and the OWASP Top 10, the standard list of website security risks. Release measures follow Google’s DORA research. Mobile builds also follow OWASP MASVS, and we report quality against ISO/IEC 25010. The badges are our own marks, not certificates.
07 · How we use AIAI drafts · engineers approve · we watch each release
AI drafts screen parts from your design kit, tests and a note on each visual change. Engineers edit and review all of it. After release, data from your real visitors decides whether a change stays.
Illustration of one change moving through the release lane in a day. At 09:10 a designer approves the design. At 09:38 AI drafts the screen part from the design kit; at 10:05 an engineer edits it. At 10:40 AI drafts fourteen Playwright tests, which the engineer reviews. At 11:12 a preview is live and every check passes. At 14:30 a person checks the AI summary of the visual changes. At 15:02 a person approves it; AI cannot approve. On Thursday the release goes out while we watch real visits. It is undone automatically if tap response for 3 in 4 visits slows by more than 20 percent. Times and values are illustrative.
Thu 10:0010% → 50% → 100% of visitors, watched live
Tokens the draft used, and what they resolve to
AddressCard.tsx · 3 files drafted+1 −5 by an engineerA raw value fails review
AI drafts an AddressCard component from the design kit’s named values in the Figma frame. It uses space.4 for padding, radius.md for the corner, text.label for the name and the neutral badge tone. An engineer then edits the empty view to add a hint and an action. A raw number in place of a named value fails review.
saved-address.spec.ts · drafted by AI2 assertions tightened by an engineerNo test counts until a person has read it
AI drafts fourteen Playwright tests. They cover keyboard use, a 320 pixel screen, screen-reader announcements, visible focus and target size. Others check 200 percent zoom, reduced motion, form errors and a dropped connection. Each test runs on four devices: Chromium and WebKit on desktop, Pixel 7 on Android and iPhone 15 on iOS. That makes fifty-six passing runs. An engineer reviews each test before it counts.
AI summary · 3 visual changes · 0 unexpected
Engineer checked it against the code · 14:30
Tap response · mobile · release 43Illustrative
Tap guard · 10% of visitors firstAutomatic undo in 48 sIncident note drafted by AI, owned by a person
Chart of tap response for 3 in 4 visits in the hour after release 43 reaches 10 percent of traffic. It holds near the 150 millisecond baseline, then rises to 205 milliseconds at 22 minutes, past the 180 millisecond guard. The release is undone automatically, back to 42, in 48 seconds. It is back at 150 milliseconds by 30 minutes; an engineer owns the fix.
Every change needs a code owner’s approval. AI accounts can propose changes and comment, but cannot approve or add them.
Every prompt, tool use and edit stays attached to the change, so the reviewer sees what the AI saw.
We use business AI tools set to keep no data. Your code never goes into a tool that learns from it.
A slow or failing release is undone in under a minute. A person decides what goes out next, and when.
Release tools · technologies we work with
08 · Lighter pagesOne product page · 6 limits · estimated
A heavy page is slower, costs more to host and uses more energy. So we set a weight limit that every build must meet. Pick a limit to see what it takes and what it blocks.
Illustrative modelA model of one product page under six weight limits. With no limit it weighs 4.10 megabytes. Images are 2,180 kilobytes, JavaScript 1,120, outside scripts 480, fonts 260, CSS 92 and the page itself 66. Under a 2.00 megabyte limit it weighs 2.00. Under 1.50 it weighs 1.49. Under 1.00 it weighs 0.90 with no feature lost; this is the limit we usually set. Under 0.75 it weighs 0.64, and the gallery loads only when opened. Under 0.50 it weighs 0.42, with no browser framework and no outside scripts. Over 100,000 views, the 4.10 megabyte page sends 420 gigabytes and emits an estimated 92 kilograms of carbon emissions. At 0.90 megabytes it sends 92 gigabytes and emits 20 kilograms. That is about 0.92 grams per view against 0.20. The figures are modelled with the Sustainable Web Design method, not measured. The table below lists every limit.
The limit we usually set. Every feature stays and the page is 78% lighter than at the start.The build blocks: Any image over 200 KB. Any page’s code over 250 KB.
| Page part | No limit | 1.00 MB | What it takes |
|---|---|---|---|
| Images | 2,180 KB | 402 KB | AVIF sized for each screen; the top image first, the rest on scroll |
| JavaScript | 1,120 KB | 214 KB | Built on the server; only the cart and gallery run code |
| Outside scripts | 480 KB | 148 KB | Analytics and consent only, on your server |
| Fonts | 260 KB | 62 KB | One trimmed font file; text shows before the font loads |
| CSS | 92 KB | 54 KB | First-screen styles sent first; the rest later |
| Page itself | 66 KB | 42 KB | Streamed, with no data holding up the page |
| Total | 4.10 MB | 0.90 MB | Every view, for as long as the page lives |
How the estimate is made
Data sent is page weight times views, in decimal gigabytes. Emissions follow the Sustainable Web Design method. It has 2 inputs: 0.494 kWh per gigabyte transferred and 442 gCO₂e per kilowatt-hour (a global-average grid). That is about 218 gCO₂e per gigabyte. The speed demo in section 03 uses the same inputs. The result is an estimate. A cached page from a low-carbon region emits far less. A first load on an old device emits more. We show the model and its inputs with every estimate. And we track what we control: bytes.
SCI = ((E × I) + M) per REnergy times grid carbon intensity, plus the carbon of making hardware, per unit of work. The Green Software Foundation’s Software Carbon Intensity standard, ISO/IEC 21031:2024.
We follow these standards, and the W3C Web Sustainability Guidelines shape the practices below.
All 6 limits · one product page
AVIF or WebP sized for each screen, with fixed sizes so nothing jumps. Lower images load on scroll. Images are usually over half the weight.
Server-built pages and code split by page, run only where needed. The build fails if code grows past its limit.
Fonts on your server, trimmed to the letters you use. Text shows before the font loads. Device fonts where the brand allows.
Every tag has an owner and a review date. Tags with no clear purpose are removed. The rest load after the visitor taps or scrolls.
Files are kept for a long time, refreshed in the background and served from a server near your visitors.
No autoplay video on phones, dark mode where visitors choose it and less motion when they ask. Less work on the device means less battery used.
The build enforces the limit. Image, script and font limits are kept with your code. The speed budget check in section 06 tests them on every change. A change that pushes the page over its limit fails. So a year of small additions cannot add the weight back.
09 · How it works5 stages · each ends with a file you keep
Stages 1 to 4 get your product live. Stage 5 uses 90 days of real visits to fix what has slowed. Each stage ends with a file you can open and a person’s sign-off.
Typical timings · sample files01Discover · Wk 01–02
We study your visitor data, support tickets and the devices and networks your customers use. That sets the speed budget, the oldest browser we support and the first release.
Before we move on

The file you receive
What you get
Signed off byYour product owner and our project lead
02Design · Wk 02–05
We design with your content and the design kit, then test a clickable draft with 5 to 8 users. Contrast, button size and keyboard order are designed in.
Before we move on
The file you receive
What you get
Signed off byYour product owner, our design lead and our senior engineer
03Build · Wk 04–11
AI drafts code and tests; engineers review and approve. Each change gets its own preview link, and each cycle ends with a demo.
Before we move on
The file you receive
What you get
Signed off byYour product owner, at the demo
04Launch · Wk 11–12
We release to a share of visitors first and watch speed and errors. If either crosses its limit, the release is undone automatically.
Before we move on
The file you receive
What you get
Signed off byYour product owner and our project lead
05Improve · Wk 12+
At day 90, real visits show which pages slowed and where people stall. We review it with you, fix the 3 worst slowdowns and reset the budgets.
Before we move on
The file you receive
What you get
Signed off byYour product owner and our project lead, at the review
01 / 05 · Discover
10 · What you get6 folders · your code · your accounts
Your engineers can copy it on day one. It holds the code, tests, speed budgets, how-to guides and the reasons behind each technical choice.
What we make for you is yours once it is paid for.
11 · What we measureTargets we design to · 3 in 4 visits
We write 3 targets into the plan and check each against your real visits, using its own data source. They guide design and budget. They are not promised results.
Targets with sample readings · IllustrativeSpeed budgets are checked on every change and measured on the devices and networks your visitors use.
Google’s 3 speed targets met for 3 in 4 visits
Sample spread of page loads across Google’s speed bands. Each value is for 3 in 4 visits. Main content shown (LCP): 78 percent good, 15 needs improvement, 7 poor; 2.1 seconds against 2.5. Tap response (INP): 84 percent good, 11 needs improvement, 5 poor; 164 milliseconds against 200. Layout shift (CLS): 91 percent good, 6 needs improvement, 3 poor; 0.04 against 0.1. All three clear the 75 percent line, so the page passes.
Targetat least 75%
Google passes a page when 3 in 4 visits are good. Good means main content within 2.5 s (LCP) and taps answered within 200 ms (INP). Layout shift must be 0.1 or less (CLS). We hold that on every key page type.
Crash reports are set up before the first release, with clear error details and an owner for every alert. Our release guard catches problems before app-store reviews do.
Sessions without a crash, mobile, last 7 days
Sample week of mobile sessions without a crash, against a 99.5 percent floor. Monday 99.72, Tuesday 99.68, Wednesday 99.81, Thursday 99.42, Friday 99.63, Saturday 99.78, Sunday 99.74. Thursday is the only day below the floor. A release caused crashes, the guard undid it and the line recovered the next day.
Targetat least 99.5%
The floor is 99.5%. For a busy app, the gap from 99.0% is thousands of broken sessions a month. A release caused Thursday’s dip. Our release guard undid it within a day.
Small releases that can be switched off, a preview for every change and automatic undo based on real-visit data.
Time to restore service after a bad release
Sample chart: time to fix the last eighteen unplanned outages. Nine took under five minutes and six took five to fifteen. Two took fifteen to thirty, one took thirty to sixty and none took over an hour. Fifteen of the eighteen are inside the fifteen-minute target.
Targetunder 15 minutes
Time to restore is 1 of the 4 DORA release measures. We report all 4. DORA’s top band is under an hour. We plan for 15 minutes because undo is automatic.
We measure business results before work starts. We track sales, enquiries, finished tasks and drop-off the same way before and after launch, for a fair comparison. We agree each target with you at the start and review it at day 90.
Offers & plans
Pick what you need built. Each offer shows what is included, the tools we usually use and a typical timeline.
How to buy
How we work with you
Ask a quick question, send your project details or request a quote. The person who will lead the work reads each one in full. Services in your enquiry go with it.
Or book a 30-minute call01
For a first chat, a press request or anything not ready to plan yet.
You get A reply from a named lead
02Recommended
Goals, who it is for, budget and timing, so our first reply can outline the work.
You get Options and prices after one call
03
Your documents, deadlines and the purchasing and security rules to meet.
You get Confirmation and a named lead
How it is priced
Each plan shows how it is priced. Work starts once we agree a written scope and price.
Opens the project form with this plan chosen.
In your enquiry
In your enquiry
In your enquiry
In your enquiry
In your enquiry
| Plan | What you get | Best for |
|---|---|---|
| SprintA short, fixed job that answers one clear question. |
|
An audit, a brand check or a test version of an app |
| ProjectOne clear job for one fixed price. |
|
A brand identity, a website, a simple app or a set of tools |
| MilestoneA bigger build in stages you approve and pay for one at a time. |
|
Work too big for one contract, such as a large app |
| RetainerA monthly team that runs and improves what we built. |
|
Monthly social media and ads, or care for live sites and apps |
| SquadOur specialists join your team and work in your tools. |
|
Teams with a clear plan that need senior people fast |
12 · Questions7 questions buyers ask
What buyers ask first: app type, website editor, code ownership, AI, support, search rankings and speed.
We recommend one early, based on what the app must do. Heavy use of the camera or sensors suits separate iPhone and Android apps. One shared app (Flutter or React Native) costs less. Many products only need a fast web app.
The one your team finds easy to use. We work with WordPress, Contentful, Sanity and Strapi. We choose by your content, your publishing steps, languages and cost.
What we make for you is yours once it is paid for. Tools we already had stay ours, and you get a free, permanent licence to use them. The code lives in your own accounts from day one.
AI drafts code and tests; an engineer approves every change. AI also gives each change a first review. Your code never goes into tools that learn from it.
We support you for a set time after launch. Then your team takes over, or we stay on through Integration & Support with agreed response times.
Yes, if we plan the move first. We list every page that earns visits or links and test every redirect. After launch we check Google’s search reports daily for a month. Rankings may shift, but no page is lost by accident.
We make page weight a rule every change must pass. A change over its image, script or font budget cannot go in. Any release that slows taps is undone automatically. At day 90 we fix the 3 worst slowdowns with you.
You will talk to the lead who would run your work.
Three ways to start
We always agree a written scope and price before work begins.
Choose one of the three ways above