How hydration works
The page arrives as finished HTML, either from server-side rendering or from a pre-built file, and the browser paints it. That is the point where the visitor can read the page. Behind the scenes the JavaScript bundle is still downloading. Once it lands, the framework runs the same component tree again in the browser, walks the elements that are already on screen, and attaches event handlers and state to them.
From that moment the page is a working application: menus open, filters apply, forms validate, links are handled by the framework rather than the browser. Nothing visible changes when hydration finishes, which is precisely what makes it easy to overlook.
Why hydration matters
It creates a window where a page looks finished but does nothing. Someone taps the menu, gets no response, taps again, and by the time the handlers attach the page receives a burst of queued input it then has to process. That experience is measured — it is what Interaction to Next Paint is designed to capture — but the damage happens before any metric is read.
The cost falls almost entirely on the processor, so it scales with the device rather than the connection. A bundle that hydrates imperceptibly on a developer’s laptop can hold a budget Android phone for a stretch the owner notices. Since that phone is the typical device for most traffic in Nepal, testing only on desktop hides the whole problem.
Where hydration goes wrong
The classic failure is a mismatch. If the HTML the server produced differs from what the client’s first render produces — a date formatted in a different time zone, a randomly generated element id, a greeting that depends on the logged-in user, a check that only works in a browser — the framework cannot reconcile the two. Depending on the version it may warn, patch the difference, or throw the server markup away and rebuild the section, which shows up as a flicker or a jump in the layout.
The second problem is scope. Whole pages are routinely hydrated when a header, a form and a carousel are the only interactive parts, so the browser does a great deal of work to reactivate paragraphs that will never be clicked. The third is content that is injected during hydration rather than merely revealed by it. Text hidden inside a closed accordion in the server HTML is fine; text that does not exist until JavaScript builds it is not, and may never be indexed.
What to do about it
Hydrate less. Split the bundle by route so a page only loads its own code, defer components that sit below the fold until they are near the viewport, and treat interactive elements as islands in a mostly static page rather than making the whole document an application. This is the single change that moves the needle most.
Then remove the mismatches. Format dates and currencies on the server, or after the component has mounted; keep random values and browser-only checks out of the first render. Make sure everything you want indexed is present in the server HTML rather than added during hydration. Finally, measure on the hardware your visitors actually use: field data in Search Console and a throttled mobile profile in PageSpeed Insights will tell you what a real phone experiences, and a serious page speed effort starts there rather than with a desktop score.
