The Evolution of Web Rendering: From jQuery to SSR, SSG, and ISR

Matt George

Fractional CTO · Founder of Injuria.ai

•7 min read•

One question has quietly driven twenty years of web architecture: where does the HTML get built? On the server before it is sent, or in the browser after it arrives? The answer has swung back and forth, and each swing fixed the real pain of the era before it while introducing new pain of its own. Understanding that arc explains why today's frameworks work the way they do, and why they can feel like they are reinventing ideas from 2004. The important thing, which I will come back to, is that the pendulum is not actually returning to where it started.

The original web: the server did everything

In the beginning, the server built the whole page. You requested a URL, a program on the server assembled a complete HTML document, often filling a template with data from a database, and sent the finished page to your browser. Think of the classic PHP, Ruby on Rails, or Django application. Every click was a full page load. The server did the work, and the browser displayed the result.

This had real strengths the industry would later rediscover and miss. The first load was fast, because the browser received ready-to-show HTML. Search engines could read the content directly. The model was simple to reason about. Its weakness was that every interaction, even a small one, meant a full round trip and a full page redraw, which felt heavy and made rich interactivity awkward.

jQuery and progressive enhancement

The thing that cracked the old model open was a single browser capability: XMLHttpRequest, the API that let JavaScript fetch data in the background without reloading the page. That capability, popularized around 2004 and later nicknamed AJAX, is what made Gmail and Google Maps feel like applications instead of documents.[2] jQuery, released in 2006, did not invent that power, it tamed it.[1] It smoothed over the maddening differences between browsers and gave everyone a simple way to find elements, change the page, and make those background requests.

The philosophy of the time was progressive enhancement. The page worked as plain server-rendered HTML, and JavaScript layered extra polish on top. The server still owned the page. JavaScript was a helper, not the foundation.

The single-page app era

Then the center of gravity moved. As web applications grew more ambitious, trying to feel like desktop software, developers wanted to stop reloading the whole page for every action. The single-page application was the answer. The server sends a mostly empty HTML shell and a large bundle of JavaScript, and that JavaScript takes over, fetching data as needed and building the entire interface in the browser.[7] This is client-side rendering. AngularJS kicked it off in 2010, and React in 2013 and Vue in 2014 made it the default way to build serious web apps for most of the decade.[3][4]

React and Vue did not win just by being newer. They introduced the architectural idea that actually made large interfaces manageable: declarative, state-driven rendering. Instead of jQuery's imperative style, where you found an element and mutated it by hand, you described what the UI should look like for a given state and let the framework figure out the minimal set of changes, often by diffing a lightweight in-memory model of the DOM. Once the app loaded, navigation felt instant, because moving between views was just JavaScript swapping out parts of the page instead of fetching a new document.

The bill for client-side rendering

The single-page approach came with costs that took a few years to fully show up. The first load got slow. The browser now had to download a large JavaScript bundle, run it, and only then fetch the data and build the page.[8] Until all of that finished, the user often stared at a blank screen or a spinner. On a fast laptop this was tolerable. On an average phone over an average connection, it could be genuinely bad.

Search was the other problem. Because the real content was assembled by JavaScript after the page loaded, anything that read the raw HTML saw an empty shell. Search engines and link previews struggled, which mattered a great deal for any site that depended on being found. The industry had traded away two of the old model's best properties, fast first paint and readable content, to get smooth interactivity.

Back to the server, with the interactivity kept

The current era is about getting both, and it became possible because of one thing the old server era never had: the same language on both ends. Node.js let a team run the exact same JavaScript and routing logic on the server and in the browser, so "render on the server" no longer meant maintaining a separate PHP or Ruby layer. That is the quiet enabler behind every term that follows.

Server-side rendering, SSR, builds the HTML on the server for each request, like the old model, but then the JavaScript takes over in the browser so navigation stays fast. The step where the client-side code attaches itself to the already-rendered HTML is called hydration, and it has a real cost worth naming: the user can see the page before they can use it, because the buttons do nothing until the JavaScript bundle downloads and runs. Closing that gap between visible and interactive is the frontier the newest frameworks are chasing, through ideas like resumability and streaming. Static site generation, SSG, goes further and builds pages ahead of time, at deploy, so they serve instantly from a cache or CDN, which is ideal for content that does not change on every request.

Incremental static regeneration, ISR, is the clever middle ground. Pages are served from a pre-built static cache for speed, but they quietly rebuild in the background on a schedule or when the underlying data changes. You get the speed of static files with content that stays reasonably fresh, without rebuilding the entire site for one update. Frameworks like Next.js made these patterns mainstream in 2020, letting a single application mix them page by page.[5] It helps that the modern server is often not one machine but edge compute distributed close to users, so server rendering today can be physically nearer the visitor than the 2004 origin server ever was.

React Server Components

The most recent step pushes the idea into the components themselves. React Server Components let individual pieces of an interface run on the server, where they can read from a database directly and send only their finished output to the browser, while other components stay interactive on the client.[6] The aim is to ship less JavaScript by default, keeping heavy data work on the server and reserving the browser for the parts that genuinely need to be interactive. It is still maturing, and it is clearly the direction the ecosystem is moving.

Why this is not a circle

Step back and the shape looks like a pendulum, but it is really a spiral. We started on the server because it was the only option. We moved to the browser to get interactivity the server model made awkward. We returned to the server because doing everything in the browser made first loads slow and content hard to find. The reason this is progress and not nostalgia is that we did not give anything back to get here. The modern server era keeps the client-side interactivity, the shared language, and the component model, and layers server rendering under them so you can choose, page by page and now component by component, how much runs where. The earlier eras forced one answer for the whole app. The honest answer was always "it depends," and the tools finally let you say so.

Sources (8)
  1. jQuery 1.0 release announcement (2006)
  2. MDN Web Docs: AJAX
  3. React versions and release history
  4. Vue.js releases and history
  5. Next.js 9.5 release notes (Incremental Static Regeneration)
  6. React Server Components (React documentation)
  7. Richard Penman, Python Web Scraping (Packt Publishing Ltd, 2015)
  8. Jennifer Robbins, Learning Web Design ("O'Reilly Media, Inc.", 2025)

Recommended reading

Core Web Vitals: What Google Measures and Why It Matters13 min readA comprehensive technical reference on Google's Core Web Vitals, explaining how the LCP, INP, and CLS metrics are measured, their impact on SEO, and the strategic tradeoffs for engineering leaders.How Browsers Render a Page: The Critical Rendering Path6 min readDownloading a page and showing it are two different jobs. The second one, turning HTML and CSS into pixels, is where most of the waiting happens. Here is how a browser does it and why some resources block the whole thing.How Web Caching and CDNs Work7 min readThe fastest request is the one you never have to make. Web caching is the layered system that avoids repeated work, and it hides one of the genuinely hard problems in computing. Here is how it holds together, and how it quietly leaks private data when it goes wrong.Web Accessibility: The WCAG Basics Every Team Should Ship12 min readA technical guide for software engineers and leaders on implementing web accessibility using the Web Content Accessibility Guidelines (WCAG), covering its principles, technical mechanisms, and practical tradeoffs.WebSockets vs. Server-Sent Events vs. Polling: Real-Time Web Options14 min readA detailed comparison of polling, Server-Sent Events, and WebSockets, explaining their mechanisms, tradeoffs, and ideal use cases for building real-time web applications.What WebAssembly Is and Why It Matters7 min readFor most of the web's life, the browser had one native language. WebAssembly changed that by giving the browser a fast, portable compile target that any language can reach, and it is quietly becoming a runtime far beyond the browser.