/projects//audit/ ).
1. The Two Waves of Google Indexing Explained
While Googlebot renders JavaScript, compute costs mean rendering is delayed—sometimes by hours or days. If internal links are generated solely through JavaScript events (e.g., onClick handlers without proper <a href> tags), Googlebot cannot discover or crawl subsequent product or blog pages during the first pass.
LIVE PLATFORM SCREEN & TELEMETRY
SEO Runway Site Audit with JavaScript Emulation — Active Workspace
Below is the exact production screen with live parameters and dummy data illustrating the diagnostic findings and remediation buttons.
2. Configuring Headless JS Audits in SEO Runway
When launching a crawl in Site Audit, enable 'Execute JavaScript (Headless Chrome)'. The audit engine compares the raw server response against the rendered DOM and flags 'DOM Content Discrepancies'—such as headings or links that disappear after hydration.
Target System: SEO Runway TECHNICAL Engine
Execution Frequency: Automated Background Queue (UTC Sync)
Tested across enterprise datasets with zero rate limiting or data loss.
3. What a Render Budget Is and Why It Runs Out
Google processes JavaScript-heavy pages in two stages. First it crawls the raw HTML. Then, when resources allow, its Web Rendering Service runs the page in an evergreen Chromium browser to see the content JavaScript produces. Rendering costs far more than fetching HTML, so it is scheduled and limited. Google doesn't publish a fixed "render budget", but in practice heavy, slow or fragile JavaScript makes it more likely that some content is rendered late, incompletely or not at all.
For users the same JavaScript has a different cost: hydration. After server-rendered HTML arrives, the framework (React, Vue, Svelte, Angular) must download, parse and execute the JavaScript that attaches event handlers and state to that HTML. Until hydration completes, the page may look ready but ignore taps and clicks. Long hydration shows up directly in Interaction to Next Paint (INP), the Core Web Vital that replaced First Input Delay.
Taming the render budget therefore serves two goals at once: making sure search engines see your content quickly and reliably, and making sure users can interact with it quickly.
4. Diagnosing Hydration and Rendering Problems
- Compare raw HTML with rendered HTML. Fetch a page with JavaScript disabled (or view the response body in a crawler) and compare it with the rendered DOM. Important content, links and metadata should already be present in the server HTML. If product descriptions, internal links or canonical tags only appear after JavaScript runs, you depend entirely on Google's rendering queue.
- Use the URL Inspection tool. In Search Console, inspect a URL and view the tested page's rendered HTML and screenshot. Missing sections, blank areas or "resources couldn't be loaded" messages point to rendering failures.
- Measure JavaScript cost. In Chrome DevTools, record a Performance profile on a mid-range mobile setting. Look at total script evaluation time, long tasks over 50 ms, and the time between first contentful paint and the point the page becomes responsive.
- Check bundle composition. Use your framework's bundle analyser to see which libraries ship to the browser. Date libraries, charting packages, icon sets and analytics SDKs are frequent offenders.
- Review INP field data. Search Console's Core Web Vitals report and the Chrome UX Report show INP from real users. Pages failing INP usually have heavy hydration or expensive event handlers.
5. Techniques That Cut Hydration Cost
Server-side rendering of indexable content
Render everything that matters for search on the server: titles, headings, body copy, product details, prices, structured data and internal links. Search engines then get complete content from the first fetch, regardless of rendering delays.
Partial and selective hydration
Not every component needs to be interactive. Frameworks now let you hydrate only the parts of the page that need it: React Server Components keep non-interactive parts as server-only output, Astro and similar "islands" architectures hydrate individual widgets, and Qwik resumes interactivity without traditional hydration. A product page might hydrate only the gallery, the variant selector and the Add to Cart button, leaving descriptions, specifications and reviews as static HTML.
Deferring non-critical JavaScript
Load chat widgets, review carousels, recommendation sliders and analytics after the main content is interactive, or when the user scrolls near them. Use dynamic imports so their code isn't in the initial bundle.
Breaking up long tasks
Long JavaScript tasks block the main thread. Split heavy initialisation into smaller chunks, yield to the browser between them, and move expensive data processing to web workers where possible.
Trimming third-party scripts
Tag managers often accumulate scripts nobody owns. Audit every third-party tag, remove those no longer used, and load the rest with appropriate priority. Each removed script is a direct saving in both rendering and hydration cost.
6. Making JavaScript Content Robust for Search
Beyond performance, several patterns determine whether Google can reliably see content that depends on JavaScript:
- Use real links. Internal navigation should use
<a href="...">elements with crawlable URLs. Links implemented as click handlers on buttons or divs are not followed. - Avoid content behind interactions. Text that only loads after a click, a hover or scrolling to a "load more" button may not be seen. Render it in the HTML and use CSS to collapse it if needed.
- Don't block resources. robots.txt must allow the JavaScript, CSS and API endpoints needed to render pages. Blocking an API that supplies product data leaves the rendered page empty.
- Handle errors gracefully. If a client-side data fetch fails, the page should still show server-rendered content rather than a blank screen.
- Keep metadata server-side. Title tags, meta descriptions, canonical tags, hreflang and robots directives should be in the initial HTML. Changing them with JavaScript after load creates conflicting signals.
- Return correct status codes. Single-page apps that show a "not found" view while returning HTTP 200 create soft 404s. Return a real 404 from the server, or add a noindex directive on error views.
7. Setting and Enforcing a JavaScript Budget
Performance improvements fade unless they are protected. Agree a budget per template and enforce it automatically:
- Initial JavaScript size, for example under 170 KB compressed for key landing templates on mobile.
- Total blocking time in the lab below a threshold such as 200 ms on a mid-range mobile profile.
- INP at the 75th percentile below 200 ms in field data, Google's "good" threshold.
- Number of third-party scripts per template, with new additions requiring review.
Run Lighthouse CI or a bundle-size check on every pull request and fail builds that exceed the budget. Pair it with real-user monitoring by route, so regressions are traced to the release that caused them.
8. A Phased Improvement Plan
- Week 1–2: Audit. Compare raw and rendered HTML for each template, profile JavaScript cost and list every third-party script.
- Week 3–4: Quick wins. Remove unused scripts and libraries, defer non-critical widgets and make sure all indexable content and links are in server HTML.
- Month 2: Structural changes. Introduce partial hydration or server components for content-heavy templates, and split large bundles by route.
- Month 3: Guardrails. Set budgets, add CI checks and report INP and crawl health together.
9. Measuring Success
Judge the work on outcomes, not bundle sizes alone. Track the share of key pages whose important content is present in raw HTML, INP pass rates in the Core Web Vitals report, time from publishing to indexing for new pages, and organic landing-page engagement on mobile. When all four move in the right direction, you have reduced the cost of your JavaScript for both search engines and users.
10. JavaScript Render Budget Checklist
- Indexable content, links and metadata present in server-rendered HTML.
- Only interactive components hydrate; static content stays static.
- Non-critical widgets and third-party scripts load after interactivity.
- Long tasks split; heavy processing moved off the main thread.
- Rendering resources allowed in robots.txt.
- Real 404 status codes for missing pages.
- JavaScript budgets enforced in CI, INP monitored in the field.
11. Framework-Specific Notes
React and Next.js
With the App Router, components are server components by default. Keep them that way unless they need state, effects or browser APIs, and push the "use client" boundary as far down the tree as possible. A whole page marked as a client component ships all of its code to the browser; a page where only the buy button is a client component ships a fraction of it. In the Pages Router, use getStaticProps or getServerSideProps so content arrives in HTML, and avoid fetching primary content in useEffect.
Vue and Nuxt
Nuxt renders on the server by default. Use lazy-hydrating components for below-the-fold widgets and the <ClientOnly> wrapper sparingly, with a placeholder of the right size. Watch for hydration mismatch warnings, which force Vue to re-render parts of the page.
Angular
Use server-side rendering with hydration enabled rather than client-only rendering, and consider deferrable views (@defer) to load heavy components only when they enter the viewport or after the page becomes idle.
Single-page apps without SSR
If a full move to server rendering isn't possible yet, prerender the most important routes to static HTML at build time. Treat dynamic rendering (serving bots a different prerendered version) as a temporary workaround only. Google describes it as a workaround rather than a long-term solution, and it adds the risk of the two versions drifting apart.
12. Explaining the Trade-off to Product Teams
Rich client-side features are often requested by product and marketing teams who never see their cost on a fast office laptop. Make the cost visible: show recordings of the page loading on a mid-range Android phone over a slow connection, and put the INP and organic traffic data for affected templates side by side. The conversation then moves from "SEO wants less JavaScript" to a shared decision about which interactions are worth their cost, and which can be delivered as plain HTML without users noticing any difference.
13. Common Mistakes When Reducing JavaScript
- Optimising the homepage only. Product, category and article templates usually carry most organic traffic and most of the JavaScript cost.
- Lazy-loading primary content. Deferring the main content to speed up a lab score hides it from users and crawlers alike. Defer only secondary widgets.
- Removing interactivity users rely on. Check analytics before removing features; some "heavy" components drive conversions.
- Testing only on fast hardware. Hydration cost scales with CPU speed. Always test on a mid-range mobile profile.
- Treating it as a one-off project. Without budgets and monitoring, JavaScript weight grows back within a few releases as new features and tags are added.
The sustainable approach is to treat JavaScript as a cost that every feature must justify, with server-rendered HTML as the default and client-side code added only where it clearly improves the experience.
Want the complete procedural runbook?
Visit our comprehensive step-by-step Knowledge Base for interactive screen maps, configuration parameters, and adjacent module workflows.
Open Knowledge Base Hub →

Bookmarked. We run this exact setup in SEO Runway across our agency client retainers. As a Principal Growth Architect, this provides exactly the architectural depth we look for.