What is documented about rendering
Google's own description of the process has three stages: crawling fetches the HTML; the page is placed in a render queue; the rendering service executes it with an evergreen (recent, regularly updated) version of Chromium, and the rendered DOM is what indexing reads. Several properties are documented and matter:
- Rendering happens after crawling and can be delayed. The gap is described as usually seconds but possibly longer when resources are constrained; content that needs rendering is therefore indexed later than content in the initial HTML.
- Googlebot does not interact. It does not click, scroll (beyond loading a tall viewport), fill forms or log in. Content behind any of those does not get rendered.
- Resources that are blocked or fail do not load. Scripts and data requests disallowed in robots.txtA file at a site's root telling crawlers which URLs they may and may not fetch., returning errors or timing out leave the page partially rendered.
- Rendered HTML is the source of truth. Meta robots tags, canonical links and titles that JavaScript changes are read from the rendered version — which also means JavaScript can accidentally remove or contradict them.
- State is not persisted. Googlebot renders stateless: no cookies carried over, no local storage from a previous visit, a fresh session each time.
What is not documented is any precise timeout or the exact rendering budget per site; statements about those are inference from observation and should be treated as such.
Failure modes
Content that needs execution
The classic case: a page's HTML contains an empty container and a script that fetches content and injects it. If rendering succeeds, the content is indexed — late. If any dependency fails, the page indexes as empty, and Google may treat it as a soft 404A page that returns a success status code but shows an error, empty or not-found message. (a "not found" page returning a success code). The same applies to titles and descriptions set by script, structured data injected at runtime and canonical tags added client-side.
Links that are not links
Navigation implemented as elements with click handlers that update the view, or <a> elements without an
href, or links with javascript: hrefs, are not followed. Google documents that it follows <a> elements
with an href attribute pointing to a resolvable URL. PaginationSplitting a long list of items, such as products or articles, across a series of numbered pages., "load more" buttons and tab panels that
reveal content on click are the common sources of unreachable pages and invisible content.
URLs without views, views without URLs
A single-page application that keeps one URL while the view changes exposes one page to the index. Fragment
URLs (#section) are not treated as separate pages. Each indexable view needs its own path, handled by the
history API, and each path must render its content on direct load — not only when reached by navigating
within the app.
Blocked resources
A script bundle or an API endpoint disallowed in robots.txt, served from a host that blocks bots, or protected by authentication, leaves the render incomplete. The URL inspection tool lists resources Googlebot could not load; a surprising share of JavaScript SEO problems are a single disallowed path.
Hydration and consistency
Frameworks that render on the server and then "hydrate" on the client can produce two different versions — the server HTML and the client's re-rendered DOM. Where they diverge (different titles, content, links), the indexer reads whichever the rendering produced; where hydration throws an error, the client may wipe the server content. Consistency between the two is a testable requirement.
Lazy loading and viewport
Content loaded when scrolled into view may never load for a crawler that does not scroll. Google documents
support for lazy-loading that triggers when content enters the viewport (for example via
IntersectionObserver) and advises against patterns that require a scroll event; it also documents native
loading="lazy" for images as supported. Infinite-scroll lists need paginated URLs behind them.
Rendering strategies compared
| Strategy | What the crawler receives | SEO risk | Typical cost |
|---|---|---|---|
| Static generation (pre-built HTML at deploy) | Complete HTML | Lowest; content and links present immediately | Build complexity; freshness depends on rebuilds |
| Server-side rendering (HTML built per request) | Complete HTML | Low; same as static with fresher data | Server load; caching needed |
| Hybrid / islands (server HTML with client interactivity on parts) | Complete HTML for content; scripts for widgets | Low if critical content is server-rendered | Framework discipline about what is client-only |
| Client-side rendering (empty shell, content via script) | A shell; content only after rendering | Highest; delayed, partial or failed indexing | Lowest server cost; highest SEO exposure |
| Dynamic rendering (pre-rendered HTML to bots, app to users) | A rendered snapshot | Medium; a workaround Google no longer recommends; cloaking risk if versions differ in content | Extra infrastructure to maintain |
The practical rule, consistent with Google's guidance: anything that must be indexed — primary content, internal links, titles, canonicals, structured data — belongs in the HTML the server sends. Interactivity can be client-side. This site follows the rule: every content page is statically generated with its text, links and metadata in the HTML, and interactive widgets hydrate on top; the rendering approach is documented in the site's own architecture notes.
The rendering strategy is often fixed by the platform, which is why the guide to choosing a CMS for SEO tests what a candidate sends in its server response before the decision is made.
Testing what Google sees
- URL inspection, live test (GSCGoogle's search performance and indexing tool.): fetch and render the URL as Googlebot, view the rendered HTML and the screenshot, and read the list of page resources that failed to load.
- Compare rendered HTML with expected content. Search the rendered source for the headline, the body text, the internal links and the metadata. Missing items are the problem list.
- Disable JavaScript in a browser and load the page. What remains is what is indexed if rendering fails. For a client-rendered site this is an empty page, which is the risk made visible.
- Check robots.txt against every resource the page loads, particularly API endpoints and script hosts.
- Crawl with and without rendering using a site crawler that supports both modes, and diff the link counts and content; pages whose links appear only in rendered mode depend on execution. Choosing between the modes, and the other settings that decide what such a crawl can show, is covered in configuring a site crawl.
- Monitor indexing coverage for JavaScript-heavy templates separately in Search Console; a widening gap between discovered and indexed URLs is the early signal.
A marketplace whose listings vanished
A marketplace rebuilt its front end as a client-rendered application. Traffic to listing pages fell over the following weeks. The URL inspection tool showed listing pages rendering with a header and an empty results container: the API that supplied listings lived on a subdomain whose robots.txt disallowed all bots, so the fetch failed and the pages indexed as near-empty, with many reported as soft 404s. Allowing the API path restored rendering, but the team also moved listing content to server-side rendering so that indexing no longer depended on the render queue, and kept the client application for filtering and interaction.
A pre-release checklist for JavaScript changes
Before any release that changes how pages render:
- The important content is present in the server response or in the rendered HTML the inspection tool shows, for each affected template.
- Every navigation and content link is an anchor with an
hrefto a real URL. - Every view that should be indexable has its own URL that returns the content when fetched directly.
- Title, meta description, canonical and robots directives are correct in the initial HTML and are not changed by script after load.
- Resources needed to render are not blocked in robots.txt.
- Lazy-loaded content that should be indexed is reachable without scrolling or user action.
- The rendered page and the server response agree.
- A crawl of staging in JavaScript-rendering mode matches a crawl in plain HTML mode on the counts that matter.
For a new template or feature, the tutorial on writing SEO requirements for developers puts these expectations into the specification, with test URLs, before development starts.
JavaScript and the rest of technical SEO
Rendering interacts with every other technical topic. Scripts are the usual cause of poor Core Web Vitals (long tasks, late content, layout shifts); client-side navigation is where site architecture breaks (links that are not links); runtime-injected canonicals and meta robots are where crawling and indexing controls go wrong; and rendering costs crawl capacity, which matters on large sites (Crawl BudgetHow much a search engine crawls a site.). A framework migration is a site migration in everything but name and deserves the same pre-launch checks.
Common mistakes
- Critical content injected by script. Indexed late or not at all; soft 404s when it fails.
- Click handlers instead of anchors. Unreachable pages.
- One URL for many views. One indexed page for a whole application.
- API or script hosts blocked in robots.txt. The single most common cause of empty renders.
- Canonical and meta robots set or changed client-side. Contradictory or missing signals.
- Testing only in a browser with JavaScript on. The crawler's view is different.
- Dynamic rendering as a permanent architecture. A workaround with its own maintenance and cloaking risks.
The technical SEO audit tutorial includes the rendering checks above as one of its steps; the author's technical SEO page lists rendering among the pillars of a technical review.
