A site can pass a Lighthouse run on a laptop and still feel dead for a few seconds on a mid-range phone: the page is visible, taps do nothing, and then the layout may shift when the JavaScript finally attaches. The call button and the form are what visitors tend to tap first, so that gap is where a business site can lose an enquiry (an opinion, not a measured figure).
This is a procedure for testing that gap on purpose. It has four steps and produces a results table you can compare release to release. It does not promise a target time. Any "X seconds to Y seconds" figure from someone else's app tells you nothing about yours.
Sources read on 2026-11-06: the React hydrateRoot reference, the Chrome DevTools Performance panel reference, and web.dev's INP article. The script in step 1 was run on 2026-11-06 (Node.js 20.20.2) against local demo pages. The DevTools steps were taken from the documentation and were not executed for this post.
Step 1: what does the server actually send?
Hydration only attaches behaviour to HTML that already exists. If the important text is not in the response, no amount of hydration tuning helps. Fetch the page without running JavaScript and look for the phrases that matter (heading, price, phone number, form labels):
// check-server-html.mjs — Node 18+; usage: node check-server-html.mjs <url> "<phrase>" ...
const [url, ...phrases] = process.argv.slice(2);
const res = await fetch(url, { redirect: 'manual' });
const html = await res.text();
console.log(`${res.status} ${url} (${html.length} bytes)`);
let missing = 0;
for (const p of phrases) {
const found = html.includes(p);
if (!found) missing++;
console.log(`${found ? 'PRESENT' : 'MISSING'} ${JSON.stringify(p)}`);
}
process.exit(missing ? 1 : 0);
Run against three local demo pages with the phrases Pricing and Plans from 499 per month:
| Demo page | Pricing |
Plans from 499 per month |
Exit |
|---|---|---|---|
| fully server-rendered | PRESENT | PRESENT | 0 |
| price component deferred to the browser | PRESENT | MISSING | 1 |
empty <div id="root"> shell |
MISSING | MISSING | 1 |
redirect: 'manual' matters: a 301 or 308 would otherwise be followed silently and you would test a different URL than you meant to.
Step 2: record a throttled trace
The DevTools Performance reference describes the controls. In Capture settings, set CPU and Network throttling. The page's only named CPU example is a 2x slowdown, and it notes that throttling is relative to your own computer, so the same setting is slower or faster on different machines. For a closer match to low- and mid-tier phones it describes Calibrate (Capture settings → CPU) to build a custom preset on a device. The page also says DevTools cannot fully simulate mobile CPUs, because their architecture differs.
Then:
- Open the Performance panel and choose Record and reload. DevTools navigates to
about:blank, records the reload, and stops a couple of seconds after load finishes. - On the Main track, look for long tasks. The reference says long tasks carry a red triangle and the part over 50 ms is shaded red. The tasks that run just before the page becomes interactive are usually framework start-up, hydration and third-party scripts; open each task's details in the Summary tab to see which.
- For a runtime check, record again without reloading: click Record, tap the primary button, then stop. The Interactions track marks interactions over 200 ms with a red triangle, and hovering shows input delay, processing time and presentation delay.
If you have a real low-end phone, use it for this step too. That is a recommendation, not a documented requirement; the DevTools page itself says desktop throttling is an approximation.
Step 3: capture hydration mismatches
React's hydrateRoot reference states that the client render is expected to match the server HTML and that mismatches should be treated as bugs. Its words on cost: "In the best case, they'll lead to a slowdown; in the worst case, event handlers can get attached to the wrong elements." Common causes it lists include browser-only checks like typeof window !== 'undefined' in render, browser-only APIs such as window.matchMedia, and rendering different data on the server and client.
React recovers from some of these automatically, so the page may look fine. The onRecoverableError option is how you find out:
import { hydrateRoot } from 'react-dom/client';
hydrateRoot(document.getElementById('root'), <App />, {
onRecoverableError(error, errorInfo) {
// send to your logging; errorInfo.componentStack shows where
console.warn('recoverable hydration error', error, errorInfo.componentStack);
},
});
The reference documents onRecoverableError(error, errorInfo) with errorInfo.componentStack. It does not list which mismatches trigger it, so treat silence as "nothing reported", not "nothing mismatched". This snippet comes from the documentation and was not run for this post. The mismatch-fixing side is covered in a separate Next.js hydration error guide.
Step 4: put numbers next to field data
Lab traces show causes. They do not show how many real visitors are affected. web.dev defines INP thresholds at the 75th percentile of field page loads, split by mobile and desktop: 200 ms or below is good, above 200 up to 500 ms needs improvement, and above 500 ms is poor. Use that to decide whether a lab finding matters, and check it against field data from a source you trust (your own real-user monitoring, for example) before and after a change.
The results table
Keep the same columns every time, and change only one thing per run:
| Run | Build / commit | Device or throttle setting | Phrases in server HTML (step 1) | Longest task before first successful tap | Interactions over 200 ms | Recoverable hydration errors | Notes |
|---|---|---|---|---|---|---|---|
| baseline | |||||||
| after change |
Fill in what you measure; leave a cell empty rather than estimating. Two runs on the same device and settings are comparable. Runs on different machines are not.
Limits
- Steps 2 and 4 were not run for this post; only step 1's script was.
- CPU throttling is relative to the machine it runs on, and DevTools says it cannot fully simulate mobile CPUs.
- "First successful tap" is a manual observation. The documented tools do not give it as a single metric.
- None of this replaces testing on the devices your customers use.
For a wider list of what to check beyond hydration, the Core Web Vitals checklist on the Prateeksha blog covers LCP, CLS and INP together.
Disclosure: the two prateeksha.com links above are to articles on my agency's blog.
What is the first thing a visitor taps on your most important page, and have you tried tapping it while it loads?
Top comments (0)