A React site goes live and everything looks fine in the browser; in Search Console, however, pages sit in the “Crawled – currently not indexed” state. The reason is usually the same: the HTML returned from the server is almost empty and content only appears after JavaScript runs. Visibility in search depends on where and when a page’s HTML is generated. Below you’ll find the differences between client-side rendering (CSR), server-side rendering (SSR), static site generation (SSG) and incremental static regeneration (ISR), how Googlebot processes JavaScript, and the right choice by page type in the Next.js App Router.
How does Google process JavaScript?
According to Google’s documentation, Googlebot processes pages containing JavaScript in three stages: crawling, rendering and indexing. The page is crawled first; for content created with JavaScript, the page is placed in the render queue and run with a browser engine when resources allow. So content created only on the client can be indexed, but it carries the risk of delays, errors and resource limits. It’s recommended that links are real <a href> elements and that meta tags and the canonical are in the initial HTML.
In practice, the risk comes up in three places. If an API call times out during rendering, Googlebot sees an empty template. If JavaScript or API paths are blocked with robots.txt, the page never gets built. The third is discovery: Googlebot finds new URLs largely through links in the HTML; if the menu works only with JavaScript events, subpages aren’t discovered. None of these stand out in the browser. The error only shows up on the search side.
Four rendering approaches
| Approach | When is the HTML generated? | Strength | Watch out for |
|---|---|---|---|
| CSR | In the browser, after JavaScript runs | Rich interaction, simple hosting | Weak first load and SEO; empty HTML |
| SSR | On the server, for every request | Up-to-date, user- or request-specific content | Server cost, TTFB |
| SSG | At build time | Fastest delivery, CDN-friendly | Regeneration when content changes |
| ISR | In advance, then refreshed in the background | Static speed + freshness | Regeneration triggers must be designed |
These four approaches are used together on a single site; the choice is made per page, not per site. While hundreds of service and blog pages on a corporate site are statically generated, the contact form’s submission endpoint and the user dashboard can run dynamically. Forcing the whole site into a single approach means either unnecessary server load or content that doesn’t get indexed.
How is the decision made in the Next.js App Router?
In App Router, components are Server Components by default: data is fetched on the server, HTML is generated on the server and only the JavaScript needed for interaction is sent to the browser. Parts that need interaction are marked as client components with "use client". Whether a page will be static or dynamic is determined by the data sources used and the cache settings. In current Next.js versions, caching decisions can be managed in more detail with the "use cache" directive and cache tags; when content is updated, the relevant tag is invalidated and the page is refreshed.
The structural mistake we see most often in the field is putting the "use client" directive on the page’s top-level component. Added for a search box or dropdown menu, this line turns the whole tree below it into client components and pushes data fetching to the browser. The right approach is the opposite: the page and content stay as server components, and only the small interactive part is moved into a separate client component. Cookie or request header reads that make a page dynamic also show up in the build output; check which routes are marked static and which dynamic during the build. For caching behavior that changes between versions, rely on the documentation for the Next.js version your project uses.
Recommendations by page type
- Corporate and service pages: static generation; on-demand revalidation of the relevant page when there’s a change in the CMS.
- Product and catalog pages: static generation + tag-based revalidation; fast-changing data such as stock in a separate, small dynamic component.
- Search and filter results: combinations you want indexed on the server; canonical and noindex rules for endless filter combinations.
- User dashboard: SSR or client; not indexed, protected with robots.
In projects using a headless CMS, the revalidation chain should be tested separately: the editor publishes content, the CMS sends a webhook, and the endpoint on the Next.js side invalidates the relevant path or tag. This endpoint must be protected with a secret key; otherwise anyone can empty the cache. A record should also be logged when the webhook fails. Silent failure means stale content.
Technical SEO checklist (React/Next.js)
- In the page source (with JavaScript disabled), are the heading, main content and internal links visible?
- Are a page-specific
title,descriptionand canonical generated on the server for every page (Metadata API)? - Do links contain a real
href, or is navigation done only with onClick? - Do 404 pages really return a 404 status code (soft-404 risk)?
- Are the sitemap and robots kept up to date with dynamic content?
- Is the structured data (JSON-LD) in the server HTML?
- Are the size of JavaScript sent to the client and the INP value being measured?
For validation, the browser’s “View page source” screen is the first step; the Elements panel in the developer tools shows the post-render DOM and is misleading. Check whether the main heading and internal links are in the HTML fetched with curl from the command line. Then use the URL Inspection tool in Search Console to check the HTML Google rendered and any resources that failed to load. The difference between the two outputs shows where the problem is.
Common mistakes
The most common mistake is making the whole page a client component and fetching data in the browser; even if the page looks fast, the initial HTML stays empty. The second mistake is making every page SSR: the server runs on every request while content rarely changes, and TTFB rises. The third is not setting up revalidation triggers; the editor changes content but the site keeps showing the old content.
Two more mistakes can be added to the list. Showing a “Content not found” message in the page component for a missing record and returning a 200 code is reported as a soft 404 in Search Console; in Next.js, notFound() should be called for this. The other is content created on the client side that doesn’t match the server HTML: dates, random ordering or browser-specific values produce hydration warnings and can cause layout shift (CLS).
Frequently asked questions
Does Google index content generated with JavaScript?
Yes; Googlebot renders JavaScript. But rendering happens in a separate stage and within resource limits; having content, links and metadata in the server HTML is the most reliable approach. Other search engines and social media previews don’t always run JavaScript.
What’s the difference between ISR and SSR?
SSR generates the page on the server for every request. ISR generates the page in advance, keeps it in the cache and refreshes it in the background after a set time or an event; this combines static speed with up-to-date content.
Does using Client Components hurt SEO?
Client Components are also rendered as HTML on the server on first load; the problem is when content is only created after data is fetched in the browser. Content data fetching should be done on the server side.
For the performance dimension, see the LCP, INP and CLS guide; for the platform decision, see the WordPress or Next.js guide. To design your project’s rendering and SEO architecture together, see our React and Next.js web applications service.