01 / Rendering
Rendering is the process of turning HTML, CSS, and JavaScript into the page a visitor sees. On JavaScript websites, the HTML the server sends can be very different from the DOM after scripts run, and search engines and AI crawlers only benefit from content they can actually render.
Earlier lessons covered crawling and indexing. This lesson adds the missing step between them: how Googlebot uses the Web Rendering Service, how client-side rendering, server-side rendering, static site generation, and hydration differ, and how to compare raw HTML with rendered HTML during an audit.
1. Raw HTML versus rendered HTML
Every JavaScript audit starts with two versions of the same URL:
| Version | What it contains | How to see it |
|---|---|---|
| Raw HTML (initial response) | The HTML document returned by the server before any JavaScript runs | View source, curl, or a crawl without rendering |
| Rendered HTML (DOM) | The document after scripts fetch data and modify the page | Browser developer tools, URL Inspection in Search Console, or a rendering crawl |
<!-- Raw HTML from a client-side rendered app -->
<body>
<div id="root"></div>
<script src="/static/js/main.4f2a.js"></script>
</body>
In this example the raw HTML contains no heading, no text, and no links. Everything depends on the JavaScript bundle executing successfully.
Content and links that exist only after rendering can still be indexed by Google, but they depend on a second, slower step. Many AI crawlers and some other bots do not execute JavaScript at all, so they only ever see the raw HTML.
2. How Google renders JavaScript
Google processes JavaScript pages in three phases: crawling, rendering, and indexing.
- CrawlGooglebot fetches the URL and reads the raw HTML. Links found in the raw HTML can be queued immediately.
- Render queueThe page waits for the Web Rendering Service, which uses an evergreen version of Chromium.
- RenderThe service executes JavaScript, loads resources that are not blocked by robots.txt, and builds the DOM.
- IndexGoogle indexes the rendered content and extracts any new links for crawling.
Rendering usually happens quickly, but it is still an extra step with limits. The renderer does not click buttons, scroll like a user, or keep state between page loads. Resources blocked in robots.txt cannot be loaded, and scripts that time out or throw errors can leave the page empty.
3. Rendering strategies
| Strategy | How it works | SEO considerations |
|---|---|---|
| Client-side rendering (CSR) | The browser downloads a shell and builds content with JavaScript | Highest risk. Content and links depend on successful rendering |
| Server-side rendering (SSR) | The server returns full HTML for each request | Content is in the raw HTML. Server load and caching need attention |
| Static site generation (SSG) | HTML is built ahead of time at deploy | Fast and reliable. Content updates need a rebuild |
| Incremental static regeneration | Static pages rebuild on a schedule or on demand | Check that stale pages do not stay cached for long |
| Hydration | Server HTML is made interactive by client JavaScript | Watch for mismatches where the client replaces server content |
| Dynamic rendering | Bots receive prerendered HTML, users receive CSR | A workaround Google no longer recommends. Content must match |
Frameworks such as Next.js, Nuxt, SvelteKit, Astro, and Angular Universal support SSR or SSG. A React or Vue single-page application without them usually relies on CSR.
4. Rendering costs and failures
Blocked resources
JavaScript or API endpoints disallowed in robots.txt.
Script errors
An uncaught error stops the app before content appears.
Slow APIs
Data requests that take too long leave placeholders in the DOM.
Consent or login walls
Content hidden until a user action the renderer never performs.
Large bundles
Heavy JavaScript slows rendering and Core Web Vitals such as INP and LCP.
Feature detection failures
Code that expects browser APIs the renderer does not provide.
5. Comparing raw and rendered versions
The most useful JavaScript SEO check is a side by side comparison of the key elements in each version.
| Element | Raw HTML | Rendered HTML | Risk if different |
|---|---|---|---|
| Title tag | Present? | Changed by JavaScript? | Google may use either version |
| Meta robots | index or noindex? | Changed? | A raw noindex can stop rendering entirely |
| Canonical | Present and correct? | Changed? | Conflicting canonicals weaken the signal |
| H1 and main text | Present? | Present? | Content only in DOM depends on rendering |
| Internal links | Count | Count | Links only in DOM are discovered later |
| Structured data | Present? | Injected? | Injected schema needs rendering to be read |
A common rendering finding
H1: none
Links: 3The server returns an app shell.
H1: Trail Running Shoes
Links: 148Content appears only after JavaScript.
Google can usually index this, but AI crawlers and slower bots see an empty page.
6. Rendering and AI crawlers
Most AI crawlers, including those used to train models and fetch pages for answers, read the raw HTML and do not execute JavaScript. A client-side rendered page may rank in Google while being blank to these systems. Serving meaningful HTML from the server is the most reliable way to be understood by both. See checking crawlability for Google, Bing, and AI bots and why AI agents are asking for markdown.
7. Testing rendering in SiteAuditLint
- Crawl without renderingRecord the raw HTML signals for every URL.
- Crawl with JavaScript renderingEnable rendering in the crawl settings and repeat the crawl.
- Compare key elementsLook for titles, headings, canonicals, and links that only exist after rendering.
- Check resource errorsReview blocked or failing scripts and API calls.
- Confirm in Search ConsoleUse URL Inspection to view Google's rendered HTML for sample pages.
The JavaScript rendering guide explains the rendering options, wait times, and when to use them.
8. Practical exercise: Compare five templates
Choose five page templates, such as the homepage, a category, a product or article, a blog listing, and a landing page. For each one, compare the raw and rendered HTML.
Rendering checklist
0 of 9 tasks completed
Key takeaways
- Raw HTML is what the server sends. Rendered HTML is what exists after JavaScript runs.
- Google crawls, renders, then indexes, so JavaScript-only content depends on an extra step.
- SSR and SSG put content in the raw HTML. CSR relies on successful rendering.
- Blocked resources, script errors, and slow APIs cause rendering failures.
- Many AI crawlers do not execute JavaScript, so server-rendered content matters for AI visibility.
- Compare raw and rendered versions of each template during an audit.
Knowledge check
Next, learn how JavaScript affects link discovery in the JavaScript links lesson, or review the guide to website crawlers.