Here’s the failure I see most on modern sites: a beautiful React or Vue app, perfect in the browser, and half its pages barely ranking. The owner swears the content is there — and it is, once the JavaScript runs. The problem is that “once the JavaScript runs” is a bet, and on anything but Google you often lose it. Rendering is where SEO quietly breaks on JavaScript-heavy sites, and it’s almost always fixable once you understand what the engine actually does.
This guide explains how search engines render JavaScript, the rendering strategies ranked from safest to riskiest, and how to confirm what Google really sees. It sits under the JavaScript SEO hub.
The short version
- Google renders JavaScript in two waves: crawl the raw HTML first, render the JS later
- Other engines and AI crawlers render JavaScript far less reliably than Google
- Content that only exists after render is content you’re betting the engine will come back for
- Safest to riskiest: SSR / static → hydration → dynamic rendering → pure client-side
- Always verify with the rendered HTML in Search Console’s URL Inspection
How Google renders JavaScript
Classic HTML sites are simple for a crawler: fetch the page, the content is right there in the response, index it. JavaScript sites add a step. With client-side rendering, the initial HTML is close to empty — a shell plus script tags — and the browser builds the actual page by running JavaScript. That means a crawler can’t just read the response; it has to execute the scripts like a browser would.
Google does exactly that, using an evergreen version of Chromium. But it happens in two separate waves, and the gap between them is the whole story.
- Wave 1: CrawlGooglebot fetches the raw HTML. If your content and links aren’t in that response, this pass sees an empty shell.
- Wave 2: QueueThe page waits in a render queue — sometimes seconds, sometimes much longer — until Google has resources to run its JavaScript.
- Wave 3: RenderChromium executes the scripts, builds the full DOM, and only now sees your real content. Whatever appears here is what gets indexed.
Two practical consequences fall out of this. First, rendering is deferred, so JavaScript-dependent content gets indexed later than HTML content — bad for anything time-sensitive. Second, discovery can stall: if your internal links only exist after render, Google may be slow to find linked pages, because it leans on wave-1 HTML to find new URLs. This is exactly why a clean XML sitemap matters so much on JavaScript sites — it discovers URLs that render-dependent links might hide.
The part nobody mentions: everything else renders worse
Most JavaScript-SEO advice is really “how to be okay with Googlebot.” But Google isn’t your only reader. Bing renders some JavaScript, less reliably. Social scrapers that build link previews typically read only the raw HTML — so a client-side-rendered page can share with no title or image. And the AI crawlers feeding answer engines render JavaScript inconsistently at best, which matters more every quarter as citations become a channel of their own.
So the honest framing isn’t “can Google handle my JavaScript.” It’s “how many of my readers see an empty page before the scripts run.” Every one of them is a reason to get your content into the first response.
Rendering strategies, safest to riskiest
You have real choices about where the HTML gets built. Here’s how they rank for SEO, and the trade-offs.
Where your HTML gets built
✓ Safer for search
- Static / SSG: HTML built at deploy time — fastest, fully present on first fetch
- SSR: server renders HTML per request — content present, dynamic data included
- Hydration: server HTML + JS attaches interactivity on top — safe if the HTML is complete first
✕ Riskier for search
- Dynamic rendering: pre-rendered HTML served to bots only — a workaround, not a fix
- Pure client-side: empty shell, everything built in-browser — bets on wave-2 render
- Hash routing (
#URLs): fragments that engines treat as one page
The principle is one line: get your important content and links into the HTML of the first response. Server-side rendering and static generation do that natively. Frameworks like Next.js, Nuxt and Astro exist largely to give you this without giving up a modern component architecture — you write the app, they ship real HTML. If you’re starting a JavaScript project and SEO matters, start here, not with pure client-side rendering you’ll have to rescue later.
Dynamic rendering — detecting bots and serving them a pre-rendered version — deserves a specific note. Google calls it a workaround, not a recommendation. It adds a system to maintain, risks drift between what bots and users see, and does nothing for the social and AI crawlers you also care about. Use it as a stopgap for a legacy app you can’t rebuild yet, not as a target architecture.
The common pitfalls
Even with a reasonable setup, specific mistakes sink JavaScript pages. Watch for these:
- Links that aren’t links. A
<div onclick>that routes via JavaScript is not a crawlable link. Use real<a href>anchors with genuine URLs so Google can follow and queue them in wave 1. - Blocked script resources. If your robots.txt blocks the JavaScript or CSS Google needs, the render fails and it sees a broken page. Never block rendering resources.
- Content behind interaction. Anything that only loads on click, scroll or hover may never be seen — Google doesn’t interact with pages. Load important content without requiring a user action.
- Soft 404s and router quirks. A client-side router that returns a 200 for a missing page creates soft 404s. Make sure real HTTP status codes reach the server.
- Timeouts. If your scripts take too long to render meaningful content, the render can capture an incomplete page. Speed here ties straight into Core Web Vitals — heavy JavaScript hurts both rendering and INP.
How to see what Google actually renders
Stop guessing — look. The single most useful tool is the URL Inspection tool in Search Console. Inspect a live URL, then view the rendered HTML and the screenshot, not just the raw source. This shows you the DOM after Google ran your JavaScript. Compare it against what you expect:
- Is your main content present in the rendered HTML? If not, it’s not getting indexed.
- Are your internal links present as real anchors? If not, discovery will lag.
- Does the screenshot look like the real page, or a broken shell? A broken render usually means a blocked resource or a script error.
A fast sanity check without any tool: disable JavaScript in your browser and load the page. What’s left is roughly what wave-1 crawlers and non-rendering bots see. If the page is blank, you have a rendering-dependency problem to solve. For the full systematic pass, rendering checks belong in your technical SEO audit.
A realistic migration path
If you’ve read this and realized your site is pure client-side rendering, don’t panic and don’t rebuild everything overnight. The fix is usually incremental. Start by identifying your SEO-critical templates — the pages that should earn organic traffic — and move those to server-side or static rendering first. A product catalog, article templates and landing pages are the priority; a logged-in dashboard that should never be indexed can stay client-side forever.
Most modern frameworks support this gradual shift. Next.js, Nuxt and SvelteKit let you choose rendering mode per route, so you can server-render the pages that matter and leave the rest. The goal isn’t architectural purity — it’s making sure every page you want ranked ships its content in the first response. Pair that migration with the checks above, verify each converted template in URL Inspection, and you close the rendering gap without a ground-up rewrite.
Frequently asked questions
Can Google index content rendered with JavaScript?
Yes. Google runs JavaScript with an evergreen Chromium and indexes the rendered result. The catch is that rendering is deferred to a second wave, and other engines and AI crawlers render far less reliably, so critical content shouldn’t depend on it.
Is server-side rendering necessary for SEO?
Not strictly, but it’s the safest path. Server-side rendering or static generation puts your content in the first HTML response, which removes the render-timing risk and works for every crawler, not just Google. For SEO-critical sites, it’s the default I recommend.
How do I know if JavaScript is hurting my SEO?
Inspect a URL in Search Console and check the rendered HTML, or load the page with JavaScript disabled. If your main content and links are missing without JavaScript, you have a rendering dependency that can slow or block indexing.
What is dynamic rendering and should I use it?
Dynamic rendering serves a pre-rendered HTML version to bots while users get the client-side app. Google treats it as a workaround, not a recommendation. Use it only as a temporary bridge for a legacy app you can’t yet move to server-side or static rendering.
JavaScript doesn’t break SEO — shipping content that only exists after a deferred render does. Get your real content and links into the first response, use real anchors, never block your scripts, and verify with the rendered HTML in Search Console. Do that and your framework works for users and search engines alike, instead of forcing you to choose.
