Plan a JavaScript SEO diagnostic: prerendering/SSR, hydration pitfalls, internal…
- User
Plan a JavaScript SEO diagnostic: prerendering/SSR, hydration pitfalls, internal linking, structured data rendering, and rendering budget checks.
Assistant
The user wants a plan for a JavaScript SEO diagnostic. The plan needs to cover specific areas:
- Prerendering/SSR (Server-Side Rendering)
- Hydration pitfalls
- Internal linking
- Structured data rendering
- Rendering budget checks
My goal is to create a comprehensive, step-by-step guide (a checklist or process) that an SEO specialist or developer can follow to diagnose these specific issues in a JavaScript-heavy website (e.g., React, Vue, Angular, Next.js, Nuxt.js).
Deconstructing the Request:
- Target Audience: Technical SEOs, Web Developers.
- Subject: JavaScript SEO.
- Scope: Diagnostic plan.
- Key Components:
- Prerendering/SSR: Is content available in the HTML response? Is it client-side only (CSR)?
- Hydration: Is the page interactive? Does the JS break the initial HTML? Does it cause layout shifts (CLS)?
- Internal Linking: Are links crawlable (
<a>tags withhref) or are they click handlers? - Structured Data: Is the JSON-LD present in the DOM (and raw HTML)? Does Google validate it?
- Rendering Budget: How long does it take to render? Is the JS bundle too big? Does it TBT (Total Blocking Time)?
Drafting the Structure:
I should structure this logically, perhaps moving from "High Level" (Tools) to "Specific Technical Checks."
- Phase 1: Preparation & Tooling: What tools do we need? (GSC, Screaming Frog, Chrome DevTools, specific URL inspection tools).
- Phase 2: The "Raw HTML" vs. "Rendered DOM" Check (Prerendering/SSR): This is the core JS SEO check.
- Phase 3: The Hydration & Interactivity Audit: Checking for errors and delays.
- Phase 4: Crawlability & Link Structure: The Internal Linking part.
- Phase 5: Structured Data Integrity: Ensuring rich results eligibility.
- Phase 6: Performance & Rendering Budget: Core Web Vitals and bot limitations.
Fleshing out the details for each section:
-
Phase 1 (Prerendering/SSR):
- Method:
View Sourcevs.Inspect Element. - Tool: Google Search Console (URL Inspection Tool) is crucial here.
- Specific Check: Is the content visible without JS executing? If using SSR/SSG (Next/Nuxt), it should be. If CSR, we need to ensure dynamic rendering or prerendering is working.
- Diagnostic Code:
curlorwgetto see the raw response headers and body.
- Method:
-
Phase 2 (Hydration):
- Concept: Server sends HTML, JS takes over.
- Issue: Hydration mismatch (HTML != Initial JS render) or broken JS preventing interactivity.
- Check: Console errors. Does clicking work immediately?
- Metric: TTFB (SSR usually increases TBT but improves LCP/FCP). CLS (Layout Shifts during hydration).
- Tool: WebPageTest or Lighthouse "DomContentLoaded" vs "Load" vs "Total Blocking Time".
-
Phase 3 (Internal Linking):
- Common JS mistake:
<div onclick="router.push(...)">instead of<a href="...">. - Check: Screaming Frog (rendered mode). Do links appear in the crawl?
- Nuance: Are links
nofollow? Are they hidden in Shadow DOM (Google can crawl Shadow DOM now, but it's tricky)?
- Common JS mistake:
-
Phase 4 (Structured Data):
- Problem: Injecting JSON-LD via client-side JS. Google can read it, but it's risky and slower.
- Check: Is it in
<script type="application/ld+json">in the raw source? - Validation: Rich Results Test. Does it see the data immediately or only after "rendering"?
-
Phase 5 (Rendering Budget):
- Concept: Googlebot has a limit on how much JS it executes.
- Metric: Bundle size. Number of requests. Main thread blocking time.
- Check: Lighthouse Performance score. Coverage tab in Chrome (unused JS).
- Bot specific: Does the site block Googlebot resources (robots.txt)?
Refining the Tone: Professional, technical, actionable. Use code snippets where helpful (e.g.,
curl). Use bullet points for readability.Self-Correction/Review during drafting:
- Initial thought: Focus heavily on React.
- Correction: Keep it framework-agnostic where possible, but acknowledge Next.js/Nuxt/React as common culprits.
- Check: Did I include "Rendering Budget"? Yes. That usually refers to the Googlebot processing power limit, but also correlates with Core Web Vitals (TBT). I need to make sure I explain why the budget matters (crawl efficiency).
Final Polish: Organize into a logical flow: "The Setup" -> "The Visual/Code Check" -> "The Google Simulation" -> "Performance". Add a "Quick Wins" section at the end for immediate fixes.
Let's write out the response based on this structure.
- Step 1: Rendering Modes. Compare Source vs. Rendered.
- Step 2: Hydration. Check for console errors and CLS.
- Step 3: Links. Use Screaming Frog.
- Step 4: Structured Data. Use Rich Results Test.
- Step 5: Budget. Analyze bundles and coverage.
The output should be a checklist or a "Standard Operating Procedure" (SOP).
(Drafting the specific points for Hydration pitfalls: Hydration mismatch, broken event listeners, "Empty Shell" syndrome). (Drafting points for Internal Linking:
hrefpresence,onClickhandlers,router-linkconversions).Okay, the plan is solid. I will structure it as a technical audit guide. This is a comprehensive technical SEO diagnostic plan focused on JavaScript (JS) heavy websites (e.g., Single Page Applications, PWA, or heavy React/Vue/Angular implementations).
Executive Summary of the Diagnostic
Objective: Determine if search engines can efficiently crawl, render, and index content without exceeding resource budgets or misinterpreting the page structure.
Tools Required:
- Google Search Console (GSC): URL Inspection Tool & Page Indexing Report.
- Chrome DevTools: View Source vs. Inspect Element, Coverage Tool, Performance Tab.
- Screaming Frog SEO Spider (v17+): With JavaScript rendering enabled.
- WebPageTest.org or Google PageSpeed Insights: For performance budgets.
Phase 1: Rendering Mode Verification (SSR vs. CSR)
Goal: Determine if content exists in the initial HTML response or requires JS execution.
1. The "View Source" vs. "Inspect" Comparison
- Action: Open the target URL. Right-click -> "View Page Source" (Ctrl+U). Then, right-click on the main content -> "Inspect" (Ctrl+Shift+I).
- Diagnostic:
- Pass: The core text content, meta tags (
<title>,<meta description>), and canonicals exist in the raw HTML (View Source). - Fail: The View Source shows a mostly empty
<body>(e.g.,<div id="root"></div>or<app-root></app-root>) or a loading spinner, while the Inspect tab shows the full content. - Implication: If the raw HTML is empty, the site relies entirely on Client-Side Rendering (CSR). You must verify if the hosting server utilizes Prerendering or Dynamic Rendering (user-agent sniffing) to serve static HTML to bots.
- Pass: The core text content, meta tags (
2. The "curl" Test (Raw Server Response)
- Action: Run
curl -A "Googlebot" [URL]in your terminal. - Diagnostic: Check if the output contains the content. If it returns empty containers but the browser shows content, Google must execute JS to see the page.
- Warning: If your site uses Server-Side Rendering (SSR), ensure the server is not rate-limiting Googlebot or blocking it via firewall rules (WAF) that mistake high crawl rates for DDoS attacks.
3. Mobile vs. Desktop Rendering
- Action: In GSC URL Inspection, toggle between "Crawled by Googlebot Smartphones" and "Googlebot Desktop."
- Diagnostic: Ensure critical content (text, images) is present in both renders. Dynamic serving sometimes fails for one user-agent.
Phase 2: Hydration Pitfalls & TTFB
Goal: Identify where the visual state and the interactive state diverge (Core Web Vitals & Indexing).
1. Critical Request Waterfall
- Action: Open DevTools -> Network tab. Throttle to "Fast 3G". Reload.
- Diagnostic: Look for the chain:
HTML->JS Bundle->Data Fetch (API)->Paint. - Pitfall: If the page body remains blank while waiting for the JS to fetch data, you have a "Double Fetch" issue (once by server, once by client) or purely CSR.
2. Hydration Mismatch (Flash of Unstyled Content - FOUC)
- Action: Observe the page load visually. Does the layout shift significantly after 2-3 seconds?
- Diagnostic:
- CLS (Cumulative Layout Shift): Does the JS inject elements that push text down?
- Content Mismatch: Does the server-rendered HTML say "Product A" but the client-side hydration fetches "Product B"? This confuses Google and can cause indexing delays.
3. Time to First Byte (TTFB) vs. TTI
- Action: Compare TTFB (Server speed) against Total Blocking Time (TBT) (JS execution speed).
- Diagnostic: High TTFB on SSR sites indicates the server is working too hard to render HTML. High TBT indicates the browser is working too hard to hydrate the page.
- Fix: If TTFB is high, implement caching (CDN) for the rendered HTML. If TBT is high, code-split your JS bundles.
Phase 3: Internal Linking & Crawlability
Goal: Ensure navigation is discoverable without executing complex JS event listeners.
1. The
<a>Tag Audit- Action: Inspect your navigation links (Header, Footer, Sidebar).
- Diagnostic:
- Pass: Code looks like
<a href="/category">Category</a>. - Fail: Code looks like
<div onclick="router.push('/category')">or<button>. - Reason: Googlebot treats standard
<a href>tags as the primary mechanism for discovering new URLs. While Google can click buttons, it is less efficient and less reliable for crawl path discovery.
- Pass: Code looks like
2. Infinite Scroll & Pagination
- Action: Check blog feeds or product listings.
- Diagnostic: If using Infinite Scroll, ensure there is a "Load More" button or standard pagination links (1, 2, 3, Next) in the HTML.
- Pitfall: Googlebot generally does not scroll. It relies on links. If the content only appears after scrolling (Intersection Observer API), Google will not discover the deep-linked products/articles.
3. Sitemap Parity
- Action: Compare
sitemap.xmlentries against the links found in the navigation. - Diagnostic: If you rely on the sitemap to get pages indexed because the internal linking structure is JS-based/broken, you have a "Orphan Page" risk. Sitemap priority is lower than internal link equity.
Phase 4: Structured Data Rendering
Goal: Verify that JSON-LD is present and valid in the DOM.
1. Placement Check (Client vs. Server)
- Action: View Source vs. Inspect Element.
- Diagnostic:
- Is the
<script type="application/ld+json">in the View Source? - If No, but Yes in Inspect Element: Your JS is injecting the schema.
- Risk: If the JS execution budget is exceeded, Google may parse the content but miss the structured data, costing you Rich Snippets.
- Is the
2. The Rich Results Test
- Action: Take a rendered URL and run it through the Google Rich Results Test.
- Diagnostic:
- If the tool fails to detect Schema that you see in the browser, your rendering logic is flawed.
- Common Error: Injecting Schema via Google Tag Manager (GTM). Note: Google officially recommends against injecting JSON-LD via GTM for SEO purposes as it is unreliable in the rendering pipeline.
Phase 5: The Rendering Budget Check
Goal: Assess if the page is "too heavy" for Google to process fully.
1. Chrome DevTools Coverage Tab
- Action: Open DevTools -> Coverage tab. Reload page.
- Diagnostic: Look at the "JS" row.
- Metric: How much of the loaded JS is actually used (Green) vs. unused (Red)?
- Threshold: If you are transferring > 500KB - 1MB of zipped JS, you are flirting with the rendering budget limit.
2. The "Gap" Analysis (Long Tasks)
- Action: DevTools -> Performance tab. Record a load interaction.
- Diagnostic: Look at the "Main" thread.
- Red Flag: Long tasks (red triangles) blocking the main thread.
- SEO Impact: If the main thread is blocked for seconds, Googlebot (which has a timeout limit, often speculated around 5-10 seconds per render cycle) may stop executing and index only the partial content.
3. Google Search Console "Page Indexing" Report
- Action: Check GSC -> Indexing -> Pages.
- Diagnostic: Look for the error reason: "Soft 404".
- JS Specific: This often happens in SPAs when a route doesn't exist, but the server returns a
200 OKstatus code with a generic "Not Found" component. You must ensure your JS framework handles 404 status codes correctly on the server side.
- JS Specific: This often happens in SPAs when a route doesn't exist, but the server returns a
Final Deliverable: The SEO Fix-List
- Code Splitting: Lazy load non-critical JavaScript.
- Hybrid Rendering: Move critical content (Top of Page, Meta, Schema) to SSR/Static generation; keep bottom-of-page interactivity CSR.
- Link Sanitization: Convert
onClickdivs to<a href>tags. - Status Code Handling: Ensure Error Pages return correct HTTP headers, not just UI components.