Guide : Rendering

TL;DR — Rendering is the step où a moteur de recherche runs votre page’s code — notamment JavaScript — in a navigateur to construire the finished page, so it peut voir votre content and liens. Google fait ce pour basically every page in its Web Rendering Service, and it usually fonctionne. How votre site produces its HTML (server, navigateur, or at construire temps) decides how safe vous are.

Ce que rendering is

Quand vous ouvrir une page, votre navigateur downloads some HTML, alors runs the CSS and JavaScript to construire lune page vous en réalité voir. Moteur de recherches do the même chose. Rendering is the step où a moteur de recherche runs votre page’s code to construire the final version of lune page, so it peut lire le contenu and follow the liens the façon vous peut.

It sits in the middle of how Google handles une page:

1. Explorer — Google downloads the raw HTML of votre URL.
2. Render — Google runs lune page’s JavaScript in a navigateur to construire the finished page.
3. Index — Google reads que finished page and fichiers it away.

Si votre content seulement montre up après JavaScript runs, Google has to render lune page successfully avant it peut voir it. So rendering is the bridge entre fetching a page and understanding it.

Google renders in a réel (but unusual) navigateur

Google’s renderer is appelé the Web Rendering Service (WRS). It’s a headless Chrome that’s “evergreen,” meaning it garde up with the current version of Chrome and supports modern web fonctionnalités. So the old fear — “Google can’t run JavaScript” — isn’t vrai. It peut. Evidence for this claim Google Search runs JavaScript with an evergreen version of Chromium. Scope: Google's Web Rendering Service; browser support does not guarantee that every application-specific interaction or resource will work. Confidence: high · Verified: 2026-07-14 Google Search Central: Fix Search-related JavaScript problems

It’s simplement an unusual navigateur. It doesn’t scroll or click, it forgets everything entre pages (aucun staying logged in), and it caches fichiers hard. Ceux quirks are où la plupart surprises come from, and the Avancé tab covers les.

The big choice: où votre HTML obtient construit

The unique la plupart important decision pour le SEO is où votre page’s HTML is produced:

• In le navigateur (rendu côté client) — le serveur sends a near-empty page and JavaScript builds everything. Riskiest pour search.
• On le serveur (rendu côté serveur) — le serveur sends a complet page. Safe.
• At construire temps (static / prerendering) — pages are construit une fois, ahead of temps. Safest and fastest.

La plupart modern frameworks mix ces. The rule of thumb: si votre important content is in the HTML avant quelconque JavaScript runs (or arrives almost immédiatement), you’re in bon shape.

Vouloir the deeper version — how the Web Rendering Service en réalité behaves, si “two waves of indexing” is encore a chose, and a complet comparison of every rendering option? Switch to the Avancé tab. Pour the practical JavaScript problems and fixes, voir JavaScript SEO.

TL;DR — Google renders votre JS in an evergreen, headless Chromium — the Web Rendering Service — to construire the DOM it indexes. It se produit pour essentially tout pages, usually dans seconds-to-minutes, so “two waves of indexing” is largely outdated and there’s aucun per-page render budget. The WRS is stateless, declines permission prompts, doesn’t interact with lune page, and caches aggressively. Votre rendering option decides votre SEO risk: SSR / static / prerendering / hydration are low-risk; complet CSR is the risky un; dynamic rendering is a workaround Google advises contre. Pour the practical JS problems ce creates, voir JavaScript SEO.

Où rendering sits

Google is explicit que JavaScript apps déplacer via three phases: “Google processes JavaScript web apps in three principal phases: 1. Exploration 2. Rendering 3. Indexation.” Evidence for this claim Google documents crawling, rendering, and indexing as the three main phases for processing JavaScript web apps. Scope: Google Search processing of JavaScript web applications; the phases can overlap operationally. Confidence: high · Verified: 2026-07-14 Google Search Central: Understand the JavaScript SEO basics Rendering is the bridge. Exploration récupère the raw HTML; rendering runs the JavaScript to construire the finished DOM; indexation reads que rendered DOM, and quelconque nouveau liens the renderer trouve obtenir fed back into exploration. In Google’s words: “During the explorer, Google renders lune page and runs quelconque JavaScript it trouve en utilisant a recent version of Chrome, similaire to how votre navigateur renders pages vous visit.”

The Web Rendering Service

Google renders in the Web Rendering Service (WRS) — a headless Chrome that’s evergreen: “Pendant que Recherche Google runs JavaScript with an evergreen version of Chromium…” it tracks current Chrome, so modern JavaScript and CSS fonctionnalités fonctionner.

The catch is que the WRS is a peculiar navigateur, and its quirks causer la plupart réel problems:

• It’s stateless. As I put it in my JavaScript SEO guide, “Google loads each page stateless like it’s a fresh load.” Google’s docs spell out the pieces: “Local Storage and Session Storage data are cleared across page loads” and “HTTP Cookies are cleared across page loads.” Don’t rely on anything persisted client-side to serve votre content.
• It declines permissions. “Expect Googlebot to decline utilisateur permission requêtes.” Content gated behind a geolocation, notification, or camera prompt won’t render.
• It doesn’t interact. Aucun scrolling, clicking, or hovering — so content que seulement loads on un of ceux events is invisible by par défaut. (Ce is the root of la plupart lazy-load and infinite-scroll bugs; the fixes live on the JavaScript SEO page.)
• It caches aggressively. “Googlebot caches aggressively in order to reduce network requêtes and resource usage. WRS may ignore mise en cache headers.” Que signifie Google peut run an outdated version of votre JS or CSS. Fix it with fichier fingerprinting — version votre filenames (app.4f2a9c.js) so a content modifier forces a fresh récupérer.

A 2026 experiment: five seconds n’est pas a hard execution wall

A third-party WRS experiment reported in July 2026 testé delayed JavaScript and network activity plutôt que assuming a five-second timeout. The observed renderer utilisé a virtual clock and completed delayed requêtes que took roughly 6–12 seconds of réel temps. The utile result is narrow: it contradicts the courant audit rule que anything occurring après exactly five seconds is automatically invisible to Google. It fait pas prove que every delayed dependency va finish, que Google waits indefinitely, or que slow client-side delivery is safe.

Lire the experiment and its methodology as third-party evidence alongside Google’s official statement que render-queue timing has aucun publié fixed delay. En pratique, tester the final DOM and requested resources. A manquant API réponse, interaction requirement, blocked script, or state dependency remains a réel rendering échec même quand a stopwatch-based “five-second rule” n’est pas.

Is “two waves of indexing” encore a chose?

Pour années the mental model was “two waves of indexing”: Google voudrait index the raw HTML premier, alors come back days or weeks plus tard to render and index the JavaScript content. Que model is now largely outdated. Martin Splitt has said the two-waves idea plays moins and moins of a role, que nombreux pages go via the render phase même quand ils don’t rely on JavaScript, and que exploration, rendering, and indexation are converging over temps.

En pratique, rendering se produit pour essentially every page, and it’s usually fast. Google’s current documentation dit a crawled page “may stay on ce queue pour a few seconds, but it peut prendre plus long que que” — there’s aucun publié fixed delay or timeout. Evidence for this claim Google says a crawled page may stay on the rendering queue for a few seconds, but it can take longer than that. Scope: Google's rendering queue for a page that returns a 200 status and is eligible for rendering. The source gives a variable duration, not a fixed timeout or service-level guarantee. Confidence: high · Verified: 2026-07-25 Google Search Central: rendering-queue duration Supports: A page may remain on the rendering queue for a few seconds or longer. As a historical données point, Google staff (Martin Splitt and Tom Greenaway) une fois put the figure at a median of à propos de five seconds, with the 90th percentile in minutes — pas the “weeks” the old fear implied. I cite que figure in my JavaScript SEO guide, but treat it as a dated conference données point plutôt que a current publié metric — Google hasn’t republished it as an ongoing number, and the queue-timing quote ci-dessus is the current official framing.

And there’s aucun render budget in the façon personnes imagine. Google doesn’t track a per-page “how expensive was this to render” score vous devez conserve. Rendering is cheap at Google’s scale — optimize pour votre utilisateurs and performances, pas a phantom render budget.

The rendering options

“Where is the HTML built?” is the question que decides votre SEO risk. The complet menu:

• Rendu côté client (CSR). Le serveur sends a near-empty shell; le navigateur (or WRS) runs JavaScript to construire everything. Ce is “the la plupart problematic un … complet rendu côté client où tout of the rendering se produit in le navigateur.” It peut fonctionner, but you’re betting everything on the render succeeding, and it’s the slowest to obtenir indexé.
• Rendu côté serveur (SSR). Le serveur builds the complet HTML pour chaque requête. Content is in the raw HTML, so it’s low-risk pour search.
• Static site generation (SSG) / prerendering. HTML is construit une fois at deploy temps. Lowest risk — content is in the raw HTML and it’s fast.
• Hydration (isomorphic / universal). Vous SSR or SSG the premier paint, alors JavaScript “hydrates” it in le navigateur to ajouter interactivity. Ce is ce que la plupart modern frameworks do, and it’s low-risk pour content — simplement watch pour hydration mismatches que blank out or replace content.
• Incremental Static Regeneration (ISR). Static pages regenerated on a schedule or on demand. Comme SSG, with fresher content — bon pour grand catalogs.
• Edge rendering. SSR run at CDN edge nodes — même low risk as SSR, with faster time-to-first-byte pour a global audience.
• Streaming SSR. HTML streamed to le navigateur in chunks as it’s ready. Low-risk, but assurez-vous indexable content isn’t trapped seulement in a late or deferred chunk.

My bottom line from my JavaScript SEO guide: “Quelconque kind of SSR, static rendering, and prerendering setup is going to be fine pour moteur de recherches. Gatsby, Suivant, Nuxt, etc., are tout great.” The framework matters moins que the rendering mode vous ship — the même Suivant.js app is safe or risky selon si vous serve SSR/SSG or complet CSR.

Dynamic rendering — a workaround, pas a strategy

Dynamic rendering signifie detecting bots and serving les a prerendered, JavaScript-free version pendant que utilisateurs obtenir the client-side version. Google is now blunt à propos de it: “Dynamic rendering was a workaround and pas a long-term solution pour problems with JavaScript-generated content in moteur de recherches,” and “Dynamic rendering is a workaround and pas a recommended solution, parce que it creates additional complexities and resource requirements.” Evidence for this claim Google describes dynamic rendering as a workaround and does not recommend it as a long-term solution. Scope: Google Search guidance for JavaScript-generated content; server-side rendering, static rendering, or hydration are the recommended alternatives. Confidence: high · Verified: 2026-07-14 Google Search Central: Dynamic rendering as a workaround I agree, and I toujours have — to be honest I jamais recommended it, and I’m glad Google now recommends contre it aussi. It’s serving différent content to bots and utilisateurs, qui is awfully fermer to cloaking. Reach pour SSR, static, or hydration à la place.

Un wrinkle: Bing encore suggests dynamic rendering. Microsoft dit “bingbot is généralement able to render JavaScript” but that doing it at scale is hard, so “we recommend dynamic rendering as a great alternative pour websites relying heavily on JavaScript.” The practical takeaway: SSR/SSG garde les deux engines happy and sidesteps the whole debate.

Ce que cela signifie pour votre content

Rendering decides si Google ever sees votre JavaScript content — but seeing it is seulement half the job. Une fois lune page is rendered, the practical concerns are réel <a href> liens, field-specific parity entre raw and rendered HTML, robots-directive stage order, lazy content, infinite scroll, and soft-404s. Ceux tout live on the JavaScript SEO page, with the testing workflow (Inspection d’URL’s rendered HTML, screenshot, and console).

Ce is the rendering stage of the search pipeline. Pour the stages autour it, voir exploration (how pages obtenir récupéré) and indexation (ce que se produit to the rendered page suivant), or the How Search Fonctionne hub pour the whole journey.

Un audit rule is worth keeping ici: rendered is a state, pas a universal winner. Pour corps content and crawlable liens, the rendered DOM montre ce que successful JavaScript ajouté or supprimé. Pour titles and descriptions, it montre additional inputs, pendant que Google may encore generate a title lien or snippet from autre sources. Pour robots directives, a raw noindex may prevent rendering, so JavaScript removal is asymmetric. Pour canonical, Google advises en utilisant un source or un JavaScript-set valeur plutôt que modification an existing valeur. And JavaScript ne peut pas modifier the HTTP réponse status déjà reçu. Garder ceux columns separate in evidence and utiliser Google’s current JavaScript SEO guidance pour the field-specific behavior.

AI summary

A condensed prendre on the Avancé version:

• Rendering = the bridge from exploration to indexation. Google runs votre JS in an evergreen, headless Chromium — the Web Rendering Service — to construire the DOM it indexes. Three phases: explorer → render → index.
• “Two waves of indexing” is largely outdated (Splitt). Rendering se produit pour essentially tout pages, usually fast. Google’s current docs dire une page “may stay on ce queue pour a few seconds, but it peut prendre plus long que que” — aucun fixed delay is publié. (A ~5s median/minutes-90th-percentile figure exists, but it’s a dated conference données point, pas a current metric.) Là is aucun per-page render budget.
• The WRS is a weird navigateur: stateless (localStorage/cookies cleared entre loads), declines permission prompts, ne fait pas scroll/click/hover, and caches JS/CSS aggressively (may ignore cache headers) → fingerprint votre filenames.
• Rendering options, by SEO risk: SSG/prerender (lowest) ≈ SSR ≈ hydration ≈ ISR ≈ edge/streaming (low) ≪ complet CSR (highest). Patrick: “SSR, static rendering, and prerendering … are tout great”; full CSR is “the la plupart problematic un.”
• Dynamic rendering is a workaround, Google advises contre it (fermer to cloaking). Bing encore recommends it — but SSR/SSG satisfies les deux.
• The framework doesn’t decide risk — the rendering mode fait. The même app is safe or risky selon si vous ship SSR/SSG or complet CSR.
• Rendering is half the job — the practical JS problems (liens, parity, lazy content, infinite scroll, soft-404s, testing) are covered on the JavaScript SEO page.

Documentation officielle

Primary-source documentation from the moteur de recherches.

Google

• Comprendre the JavaScript SEO basics — the three phases (explorer → render → index) and the evergreen Chromium renderer.
• Fix Search-related JavaScript problems — the WRS constraints: stateless storage/cookies, declined permissions, aggressive mise en cache.
• Dynamic rendering as a workaround — pourquoi dynamic rendering is a workaround, pas a recommended long-term solution.
• In-Depth Guide to How Recherche Google Fonctionne — où rendering sits in explorer → index → serve.

Bing / Microsoft

• bingbot Series: JavaScript, Dynamic Rendering, and Cloaking. Oh My! — Bing’s stance que it peut render JS but recommends dynamic rendering at scale.
• The nouveau evergreen Bingbot — Bingbot rendering on Chromium-based Microsoft Edge.

Quotes from the source

On-the-record statements from Google and Bing (plus a few from my propre writing). Chaque search-engine lien is a deep lien que jumps to the quoted passage on the source page.

Google — the render pipeline

• “Google processes JavaScript web apps in three main phases: 1. Crawling 2. Rendering 3. Indexing.” Jump to quote
• “During the crawl, Google renders the page and runs any JavaScript it finds using a recent version of Chrome, similar to how your browser renders pages you visit.” Jump to quote
• “While Google Search runs JavaScript with an evergreen version of Chromium…” Jump to quote
• “The page may stay on this queue for a few seconds, but it can take longer than that.” — the current official framing on render-queue timing; aucun fixed delay is publié. Jump to quote

Google — the Web Rendering Service

• “Local Storage and Session Storage data are cleared across page loads.” Jump to quote
• “HTTP Cookies are cleared across page loads.” Jump to quote
• “Expect Googlebot to decline user permission requests.” Jump to quote
• “Googlebot caches aggressively in order to reduce network requests and resource usage. WRS may ignore caching headers.” Jump to quote

Google — dynamic rendering

• “Dynamic rendering was a workaround and not a long-term solution for problems with JavaScript-generated content in search engines.” Jump to quote
• “Dynamic rendering is a workaround and not a recommended solution, because it creates additional complexities and resource requirements.” Jump to quote

Microsoft Bing

• “bingbot is generally able to render JavaScript…” Jump to quote
• “we recommend dynamic rendering as a great alternative for websites relying heavily on JavaScript.” Jump to quote

Martin Splitt, Google (relayed via Onely’s transcript of a 2019 Webmaster Central hangout)

• On the two-waves model: Splitt has said it plays moins and moins of a role, que nombreux sites go via the render phase même sans JavaScript, and que exploration, rendering, and indexation are converging. Lire the coverage

Patrick Stox (my propre fonctionner — JavaScript SEO: A Definitive Guide)

• “Google loads each page stateless like it’s a fresh load.”
• “pages went to the renderer at a median time of five seconds” (90th percentile in minutes) — a dated conference-era données point, pas a current publié metric; voir the current official queue-timing quote ci-dessus.
• “The most problematic one is going to be full client-side rendering where all of the rendering happens in the browser.”
• “Any kind of SSR, static rendering, and prerendering setup is going to be fine for search engines. Gatsby, Next, Nuxt, etc., are all great.”

The mental models

1. Explorer → render → index. Rendering is the bridge. Exploration récupère the raw HTML; rendering runs the JS to construire the DOM; indexation reads que DOM. Quand JS content goes manquant, demander qui step failed — was it récupéré? rendered? did the rendered DOM contain le contenu?

2. The renderer is a réel navigateur with amnesia. Evergreen Chrome, but stateless (forgets cookies/storage entre pages), aucun interaction (won’t scroll or click), and cache-happy (may run stale JS/CSS). Design as si every visit is a fresh, untouched, premier charger.

3. Rendering mode decides votre risk, pas votre framework. SSR, static, prerender, and hydration tout put content in (or quickly into) the DOM — low risk. Complet CSR bets everything on the render — highest risk. The même Suivant.js app is safe or risky selon qui mode vous ship.

4. “Two waves” is the old map. Don’t plan autour a deferred second wave of rendering days plus tard. Rendering se produit pour essentially tout pages, usually dans seconds-to-minutes — and there’s aucun render budget to ration.

5. Dynamic rendering is a smell, pas a strategy. Serving bots différent HTML que utilisateurs is a workaround Google advises contre (and is fermer to cloaking). Si you’re reaching pour it, the réel fix is usually SSR/SSG.

6. Obtenir content into the DOM, alors vérifier. Pick a mode que puts content in the rendered DOM quickly, alors confirmer with URL Inspection’s rendered HTML. Votre navigateur isn’t Googlebot.

Rendering options — SEO trade-offs

Web Rendering Service — rapide facts

Render-readiness audit checklist

A réussir to confirmer votre important content en réalité survives rendering:

• Principal content and principal navigation liens are présent in the raw HTML réponse (view source, pas DevTools’ inspected DOM) — pas injected seulement après JavaScript runs.
• Every lien interne a reader nécessite to follow is a réel <a href="..."> — pas a <div onclick>, a hash-only route (#/page), or a button que pushes state client-side with aucun matching lien.
• Aucun critical JS or CSS fichiers are blocked in robots.txt (a blocked bundle peut leave the WRS unable to construire lune page it nécessite to render).
• Content que loads on scroll, hover, or click aussi has a chemin que renders sans quelconque interaction — the WRS doesn’t scroll, click, or hover.
• Nothing important dépend on localStorage, sessionStorage, or cookies persisting entre requêtes — the WRS is stateless and clears tout of que entre page loads.
• Nothing important sits behind a geolocation, notification, or camera permission prompt — the WRS declines ceux by par défaut.
• JS/CSS filenames are fingerprinted (app.4f2a9c.js) so a content modifier forces a fresh récupérer au lieu de getting served from the WRS’s aggressive cache.
• Inspection d’URL’s rendered HTML/screenshot dans la recherche Google Console montre the même content and liens vous voir in votre propre navigateur.
• Le site isn’t en utilisant dynamic rendering as its réponse to a CSR problem — the fix is SSR, static rendering, or hydration, pas serving bots a différent version of lune page.

Rendering mistakes que en réalité bite

Blocking the JS or CSS lune page nécessite to render, in robots.txt. Si the WRS can’t récupérer a script or stylesheet lune page dépend on, it can’t construire an accurate rendered DOM — vous obtenir a broken or vide render au lieu de lune page vous intended. Do à la place: autoriser exploration of votre JS/CSS assets; robots.txt devrait garder bots out of low-value spaces, pas the resources votre propre pages besoin.

Shipping content-critical pages as complet rendu côté client (CSR) with aucun fallback. CSR is “the la plupart problematic un … complet rendu côté client où tout of the rendering se produit in le navigateur” — it bets votre entier page on the render succeeding, and it’s the slowest option to obtenir indexé. Do à la place: reach pour SSR, static generation/prerendering, or hydration so content is in (or very quickly into) the raw HTML.

Relying on hash-based routes (#/product/123) as votre seulement navigation. The WRS follows réel <a href> liens; a hash fragment que seulement changements client-side state, with aucun server-rendered equivalent URL, donne the renderer nothing to explorer onward to. Do à la place: utiliser réel paths le serveur peut respond to directement (/product/123), même in a client-heavy app.

Lazy-loading content with aucun non-interactive chemin to it. Parce que the WRS “doesn’t scroll, click, or hover,” content que seulement apparaît après un of ceux events is invisible to it by par défaut. Do à la place: charger above-the-fold and reasonably-near-viewport content sans requiring an interaction, and reserve vrai lazy-loading pour content genuinely ci-dessous the fold with a proper non-JS fallback.

Treating dynamic rendering as a long-term fix au lieu de a workaround. Google is explicit que “dynamic rendering is a workaround and pas a recommended solution, parce que it creates additional complexities and resource requirements” — and serving bots différent content que utilisateurs sits uncomfortably fermer to cloaking. Do à la place: fix the rendering mode itself (SSR/static/hydration) plutôt que building a bot-detection couche autour a CSR problem.

Validation tests

Réussir/échouer checks to confirmer a rendering fix en réalité took effect — run ces après vous ship the modifier, pas as an ongoing health metric.

Tester: content now apparaît in the rendered DOM

• Tester to run — Submit l’URL to Recherche Google Console’s URL Inspection outil and utiliser “Test Live URL,” alors ouvrir the rendered HTML tab (or run lune page via the Render Gap outil to diff raw vs. rendered HTML directement).
• Attendu result — Le contenu vous ajouté or fixed apparaît in the rendered HTML/DOM view, pas simplement in votre propre browser’s dev outils.
• Échec interpretation — Si it’s encore manquant from the rendered HTML but présent quand vous view lune page normally, the WRS encore can’t construire it — vérifier pour a blocked JS/CSS resource, an interaction-only charger, or a client-storage dependency avant assuming the fix worked.
• Monitoring window — Immediate; Inspection d’URL’s live tester reflects the current state of l’URL correct away.
• Rollback trigger — The rendered HTML encore doesn’t contain le contenu après the fix, or the live tester throws a nouveau explorer/render error it didn’t throw avant.

Tester: important liens survive the render

• Tester to run — Vérifier the rendered HTML (Inspection d’URL or Render Gap) pour réel <a href> tags autour every lien a reader nécessite to follow, pas simplement visible clickable elements.
• Attendu result — Chaque lien in the rendered DOM has a resolvable href pointing at a réel, crawlable URL.
• Échec interpretation — A manquant or vide href on ce que semble comme a working lien usually signifie it’s a <div>/<button> with a client-side click handler and aucun server-renderable chemin — the WRS can’t follow it.
• Monitoring window — Immediate.
• Rollback trigger — Liens que mattered avant the modifier are manquant href attributes or point at a hash-only fragment in the rendered output.

Tester: the fix doesn’t quietly regress on the suivant deploy

• Tester to run — Re-run the rendered-HTML vérifier (Inspection d’URL live tester or Render Gap) après votre suivant deploy que touches ce page’s templates or construire pipeline.
• Attendu result — The même content and liens are encore présent in the rendered DOM as quand vous premier confirmed the fix.
• Échec interpretation — Si content que was présent disappears à nouveau, a plus tard modifier probable reintroduced a client-only dependency or broke a server-rendered chemin.
• Monitoring window — Re-check après chaque deploy que touches the affected templates; pas a one-time vérifier.
• Rollback trigger — Content or liens que were confirmed présent drop out of the rendered DOM à nouveau.

Ressources utiles

My connexe writing

• JavaScript SEO: A Definitive Guide — my complet guide to rendering, rendering modes, DOM parity, infinite scroll, and the two-pages-as-one problem.
• The Beginner’s Guide to SEO technique — où rendering fits entre exploration and indexation.

My speaking

• How Search Fonctionne (SlideShare) — my walkthrough of exploration, rendering (the WRS, stateless loads, aucun interaction), indexation, and ranking. (My standing disclaimer s’applique: “This is my understanding of systems… not going to be 100% complete or accurate.”)

From others

• web.dev — Rendering on the Web — the canonical explainer of CSR / SSR / SSG / hydration trade-offs from the Chrome team.
• Onely — Google’s Two Waves of Indexation — transcript-based coverage of Martin Splitt’s office-hours session explaining pourquoi the two-waves model is fading; cited in the article corps.
• Moteur de recherche Roundtable — Google: Aucun Per-Page Search Cost — Google rep clarifying là is aucun per-page explorer/render/index cost to ration.
• Moteur de recherche Journal — JavaScript SEO — industry coverage of JS SEO meilleur practices, testing workflows, and framework considerations.
• Vercel — Rendering Strategies — Suivant.js/edge rendering docs; utile quand choosing entre CSR, SSR, SSG, ISR, and streaming SSR pour a réel project.
• r/TechSEO — the community pour debugging render/index problems.

Videos

• Recherche Google Central (YouTube) — Martin Splitt’s JavaScript SEO series and the rendering explainers are the meilleur official video walkthroughs of how the Web Rendering Service handles votre JS. Channel

Stats worth citing

• Current official framing: aucun fixed delay. Google’s documentation dit a crawled page “may stay on ce queue pour a few seconds, but it peut prendre plus long que que” — there’s aucun publié fixed delay or timeout pour the render queue.
• Historical données point (dated) — ~5 second median render delay. In précédent conference remarks, Google staff (Martin Splitt and Tom Greenaway) put pages reaching the renderer at a median of ~5 seconds, with the 90th percentile in minutes — pas the “weeks” the old two-waves fear implied. I cite ce in my JavaScript SEO guide, but treat it as a historical données point, pas a current publié metric — Google hasn’t republished it as an ongoing figure.
• Two waves of indexation is fading. Per Martin Splitt, the two-waves model plays moins and moins of a role as exploration, rendering, and indexation converge — rendering now se produit pour essentially tout pages. Coverage
• Aucun per-page render budget. Google has indicated it doesn’t track how expensive an individual page is to explorer, render, index, or serve — so there’s aucun “render budget” to conserve the façon budget d’exploration obtient discussed. Coverage

Testez vos connaissances: Rendering

Five rapide questions on how Google renders pages. Pick an réponse pour chaque, alors vérifier.

Journal des modifications