For years, frontend performance has been constrained by a hidden tax: hydration. Even when you ship server‑rendered HTML, most JavaScript frameworks still need to re‑run rendering logic in the browser before anything becomes truly interactive. On fast laptops this may feel acceptable; on mid‑range phones and slow networks, it turns into visible jank, delayed input, and disappointing Core Web Vitals scores.
Resumable rendering offers a radically different path toward instant pages. Instead of hydrating the UI from scratch on the client, frameworks like Qwik serialize all the necessary state and framework metadata directly into the HTML. When the browser loads the page, it can resume the app exactly where the server left off, with near zero JavaScript on initial load. The result is time‑to‑interactive that closely tracks first contentful paint, giving users an experience that feels effectively instant.
Resumable Rendering vs Hydration: What Actually Changes?
Hydration is the process most SSR frameworks use to “wake up” a server‑rendered page in the browser. The server generates HTML, sends it to the client, and then a large JavaScript bundle runs to rebuild the component tree, attach event listeners, and sync state. This means the rendering work is effectively done twice, once on the server and once on the client. Articles and conference papers from 2024, 2026 repeatedly describe this as duplicated work and “pure over” tied to hydration.
Resumable rendering flips that model. As Qwik’s documentation explains, a resumable framework encodes framework state, component boundaries, and application data directly into the HTML. Instead of recomputing everything, the browser reads this serialized state and simply wires up interactivity on demand. There is no global hydration pass, and no need to replay the entire render pipeline in JavaScript before users can click or type.
The impact is profound: frameworks using hydration must always pay the hydration cost at runtime, while resumable frameworks can skip it entirely. A 2026 cost analysis on LinkedIn notes that if two frameworks generate the same UI, the hydrated version still incurs extra CPU time and JavaScript execution, whereas the resumable one does not. This structural difference is what makes instant pages realistic even for complex, content‑heavy interfaces.
Why Hydration Is Pure Over for Instant Pages
From a performance perspective, hydration has three big drawbacks. First, it requires shipping a substantial JavaScript bundle up front, even for parts of the page the user may never interact with. Second, it must re‑execute rendering logic that has already run on the server, burning CPU cycles on every device. Third, interactivity is delayed until this work finishes, meaning time‑to‑interactive (TTI) lags far behind first contentful paint (FCP).
A Builder.io benchmark titled “Hydration is pure over” illustrates this clearly. The same page implemented with traditional hydration scored around 50/100 on Google PageSpeed, while the resumable Qwik version scored a perfect 100/100. The markup and visual output were similar, but the hydrated page had to pay the extra cost of re‑initializing the app, downloading more JavaScript, and running it eagerly, which hurt Core Web Vitals.
These findings echo academic and industry papers from 2024, 2026 that describe hydration’s JavaScript tax as increasingly misaligned with modern web performance goals. When most users are on mobile devices with limited CPU and constrained networks, any architecture that forces the browser to redo server work will struggle to deliver truly instant experiences. Resumable rendering addresses that structural cost directly instead of trying to micro‑optimize around it.
Resumability: Zero‑JS on Load and TTI ≈ FCP
One of the most striking promises of resumability is “zero JavaScript on load.” Qwik is frequently cited as the flagship example: its docs and community materials emphasize that the initial HTML response can contain everything needed to display and conceptually “boot” the app, without sending any framework code at first. Instead, the app’s state and wiring live in the HTML as serialized metadata.
A popular 2025 article titled “Resumability is the future of frontend in 2025” breaks this down: resumable frameworks like Qwik aim to execute no JavaScript during the initial page load, letting TTI approximate FCP. That means that as soon as the first render appears, the page is effectively interactive for all the content that doesn’t yet require extra logic. When interaction is needed, the framework then fetches just the tiny code fragments necessary to handle that interaction.
This approach radically changes performance characteristics. Instead of a big initial bootstrap followed by small incremental updates, resumability gives you an almost flat startup profile. On slow connections, users still see a complete, working UI quickly, without waiting for megabytes of scripts. On low‑end devices, CPU stays cool because the browser is not forced to spin up a massive hydration routine before accepting input. In real‑world terms, pages feel instant, and that feeling is what drives higher engagement and better conversion.
Inside Qwik: Progressive Loading as the Default
Qwik’s official concepts pages describe its core philosophy as simple but radical: delay loading and executing JavaScript for as long as possible. Instead of shipping event handlers, component logic, and routing code up front, Qwik keeps them on the server and treats them as fine‑grained, on‑demand resources. Only when a specific interaction occurs does the browser fetch the relevant code to handle it.
In practice, this means components and routes become “resumable islands.” Each island’s state and wiring are encoded into the HTML, so the framework does not need a global hydration pass. When you click a button, Qwik looks up the associated serialized handler, fetches the tiny code chunk that implements it, and executes just that. No full app bootstrap, no re‑render of the whole page, and no eager download of code for parts of the UI that remain idle.
Qwik 1.14, released in 2025, pushes this idea further with JavaScript Streaming and a built‑in Preloader. Instead of waiting for a full bundle, Qwik can stream executable chunks as they arrive, similar to buffering a video. The Preloader can also anticipate likely interactions or navigations and fetch code in the background. Combined with resumability, this streaming model shortens the already tiny gap between user intent and actual interaction, making even complex interfaces feel instantaneous.
Lazy Execution, Prefetching, and Instant Navigation
Resumable rendering is not just about the first page load; it also transforms navigation and subsequent interactions. A widely shared Qwik demo on Reddit describes “prefetching + resumability” as “lazy execution,” comparing it to streaming a video instead of downloading the whole file before watching. When you hover over or focus a link, Qwik can prefetch just enough code and data so that when you click, the transition feels instant.
This style of lazy execution means you never pay the full cost of your application upfront. Code is downloaded and run only when it is genuinely needed, and even then, only in small pieces. Route transitions become lightweight because there is no global re‑hydration or full bundle evaluation. Instead, each route resumes from its serialized state, pulls in any missing components, and updates the view with minimal work.
From a UX perspective, this produces what many developers describe as “instant navigation.” Users click around large sites, CMSes, dashboards, catalogs, and still experience snappy transitions comparable to native apps. For teams working on content‑rich sites with many templates and routes, this is crucial: you can scale the size and complexity of your app without paying a linear cost in startup and navigation performance.
Core Web Vitals and the Metrics That Matter
Instant pages are not just a nice‑to‑have; they are tightly aligned with measurable performance goals. Core Web Vitals, especially Largest Contentful Paint (LCP), First Input Delay (FID)/Interaction to Next Paint (INP), and Cumulative Layout Shift (CLS), are now key ranking signals and user satisfaction indicators. Hydration‑heavy architectures often struggle here because they front‑load JavaScript work, delaying interactivity and causing CPU spikes right after load.
Resumable frameworks have a structural advantage. By eliminating the hydration phase, they reduce JavaScript execution during the critical loading window, helping FCP, LCP, and INP all at once. Industry and academic papers from 2025 and 2026 explicitly argue that resumability better aligns with Core Web Vitals targets than traditional SSR+hydration, because less JS is shipped and less work is done on the main thread before the user can interact.
Real‑world tooling confirms this advantage. In the Builder.io PageSpeed comparison, the resumable Qwik implementation reaches 100/100 where the hydrated variant tops out near 50/100. The difference is not styling or markup; it is the presence or absence of hydration over. When JavaScript becomes an incremental, on‑demand resource instead of a monolithic prerequisite, the metrics tend to follow the user’s perception: fast, stable, interactive pages from the first paint.
Beyond Qwik: Resumability as an Industry Trend
While Qwik is currently the most prominent fully resumable framework, the underlying ideas are spreading. Research on modular rendering and adaptive hydration in React and Next.js shows that the ecosystem is moving toward more granular, on‑demand activation of UI. Techniques like partial hydration, island architecture, and route‑based code splitting are attempts to capture some benefits of resumability within existing paradigms.
Recent papers and blog posts in 2025, 2026 frame resumability as a general architectural pattern rather than a framework‑specific trick. They argue that treating routes and components as independently resumable units, each with its own serialized state and lazy‑loaded logic, is the natural evolution for large web applications. The motivation is consistent: deliver instant‑feeling UX, especially on mobile and low‑bandwidth connections, while keeping Core Web Vitals within target ranges.
Developer education is catching up as well. The 2025 Frontend Masters course “Qwik for Instant‑Loading Websites & Apps” focuses explicitly on building instant pages using resumability. As more courses, conference talks, and open‑source experiments explore these patterns, it is likely that resumable concepts will permeate other tooling, whether through native support or third‑party libraries that bring serialized state and lazy execution to existing stacks.
When Should You Consider Resumable Rendering?
Not every project needs a full architectural shift on day one, but certain scenarios strongly benefit from resumability. Large content sites, e‑commerce catalogs, dashboards with many widgets, and marketing pages targeting global mobile audiences are prime candidates. These apps often have substantial HTML output, many routes, and diverse interaction patterns, exactly where hydration over can hurt the most.
If you find yourself fighting to meet Core Web Vitals despite aggressive code splitting, lazy loading, and server‑side rendering, it may be a sign that hydration itself is the bottleneck. In those cases, moving to a resumable framework like Qwik, or adopting resumability‑inspired techniques where possible, can remove the biggest source of redundant work. The payoff is especially noticeable on mid‑ and low‑tier devices, where CPU is precious and every millisecond of main‑thread blocking is visible.
Even if a full migration is not feasible immediately, thinking in resumable terms can guide better decisions. Serialize meaningful state into HTML instead of recomputing it on the client. Break your app into independent islands that can activate separately. Defer JavaScript execution until it is strictly necessary. These practices all move you closer to the instant‑page ideal, regardless of the framework you currently use.
Resumable rendering represents more than a minor optimization; it is a fundamental rethinking of how web apps start, load, and respond. By encoding framework and application state into HTML, frameworks like Qwik allow the browser to resume an app without the heavy, redundant hydration step. That shift enables zero‑JS initial loads, near‑instant time‑to‑interactive, and navigation that feels effortless even in large, complex applications.
As performance expectations rise and more users access the web on constrained devices, architectures that avoid unnecessary JavaScript work will increasingly define the standard for great UX. Hydration will not disappear overnight, but its role is already being questioned by both practitioners and researchers. Resumability, with its lazy execution, progressive loading, and route‑level islands, offers a compelling path forward for instant pages, and it is a pattern the wider ecosystem is already starting to adopt.