Back to blog
November 5, 2026•31 views

Next.js Doesn't Render Pages Anymore: A Practical Guide to RSC Streaming, Suspense, and SEO

Next.jsReact Server ComponentsStreamingSuspenseSEOCore Web VitalsApp Router
Next.js Doesn't Render Pages Anymore: A Practical Guide to RSC Streaming, Suspense, and SEO

The first time I opened View Source on a Next.js App Router page and saw the shell arrive with holes in it, I had to stop and think. The <body> was there, the header was there, but chunks of content were missing and replaced by a loading skeleton. Then, over the next few hundred milliseconds, more HTML kept arriving. Same connection. Same response. Just... later.

That is the shift nobody warns you about when you move from Pages Router to App Router. Next.js doesn't render a page and hand you a finished document anymore. It renders a shell, flushes it, and streams the rest as React Server Components resolve. Which is great for perceived performance and genuinely useful for SEO, right up until it isn't. I've shipped enough of these to have opinions about where the line sits.

This guide is about that line. How RSC streaming actually works, where Suspense boundaries belong, how Googlebot handles partial HTML, and the metadata traps that quietly break indexing in streamed apps. If you're newer to the App Router's caching layer underneath all this, my Next.js 15 caching guide covers the parts that interact most with streaming.

What actually changed: from one render to a stream

In the old model, Next.js waited for everything. Data fetching, component tree, HTML string. Only then did it send the first byte. A slow database call meant a slow TTFB for the whole page, even the parts that had nothing to do with that query.

With React Server Components and streaming, the server sends an initial shell immediately, then flushes additional HTML as each Suspense boundary resolves. React's streaming runtime sends the fallback first, then a small inline script that swaps in the real content when the chunk arrives. (The React docs describe this mechanism in the Suspense reference and the renderToPipeableStream API.)

Here's the mental model:

[ t=0ms ]    HTML shell + Suspense fallbacks + <script> runtime
[ t=80ms ]   Header, nav, static sections
[ t=300ms ]  Product list chunk arrives, swapped in
[ t=650ms ]  Reviews chunk arrives, swapped in
[ t=900ms ]  Stream closes

Three things follow from this, and they matter more than most tutorials admit:

  1. TTFB drops dramatically because you're no longer blocked on your slowest query.
  2. FCP and LCP can improve because the browser paints something real almost immediately.
  3. Your HTML is no longer a single complete document at any point in time, which is where SEO questions start.

How Googlebot actually handles streamed HTML

Googlebot uses a recent Chromium, so it executes JavaScript and it does wait for the stream to complete before it considers the page loaded. In practice, streamed RSC content is crawlable. I've indexed plenty of streamed pages without a prerender service.

But "crawlable in principle" and "reliably indexed at scale" are different things. The failure modes I've seen:

  • Crawl budget pressure. If your slowest Suspense boundary takes 4 seconds to resolve, Googlebot (and every real user) waits. Multiply that across thousands of URLs and you're burning crawl budget on streams that should have been shorter.
  • Timeouts on the renderer. Google's rendering service has limits. If a boundary depends on a third-party API that occasionally hangs for 30 seconds, some percentage of crawls will render an incomplete page. Not most. Some. That's enough to cause flaky indexing.
  • Content behind interaction. If your main content only appears after a client-side fetch triggered by a click or an intersection observer, it is not in the streamed HTML and it is not reliably indexed. Streaming is not a substitute for server rendering; it's a delivery mechanism for it.

The rule I follow: anything that matters for ranking must be in the streamed HTML, not fetched after hydration. Suspense fallbacks are fine for secondary content. Never for your H1, your primary copy, or your product data.

The Suspense fallback is not the content

One mistake I see repeatedly: developers put a skeleton in the fallback and forget that the skeleton is real HTML that ships to the crawler. If your fallback says "Loading products..." and the actual products never resolve during the crawl, that string is what gets indexed. Keep fallbacks semantically neutral and short. Don't put marketing copy in them.

Placing Suspense boundaries without wrecking Core Web Vitals

A Suspense boundary is a performance decision disguised as a code structure decision. Put it in the wrong place and you trade a fast TTFB for a layout shift that tanks your CLS score.

The layout shift problem

This is the one that bites people. Your fallback renders at 200px tall. The real content renders at 900px. When the swap happens, everything below jumps. On mobile, that's a visible, jarring shift and a CLS penalty.

Two fixes that actually work:

  • Reserve height in the fallback. Give the skeleton the same approximate dimensions as the loaded content. Use min-height on the wrapper, not on the skeleton itself, so the container doesn't collapse.
  • Use aspect-ratio for media. Images and video inside streamed sections should have their aspect ratio declared in CSS so the box is stable before the bytes arrive.
// app/products/page.tsx
import { Suspense } from 'react';
import { ProductGrid } from '@/components/product-grid';
import { ProductGridSkeleton } from '@/components/skeletons';

export default function ProductsPage() {
  return (
    <main>
      <h1>All products</h1>
      <Suspense fallback={<ProductGridSkeleton rows={3} />}>
        <ProductGrid />
      </Suspense>
    </main>
  );
}

The ProductGridSkeleton should render three rows of placeholder cards at the same height as real cards. If your real grid is 3 rows of 280px cards, the skeleton should be 3 rows of 280px cards. Not a spinner. Not a 40px "Loading..." line.

Where to put the boundary, practically

Boundary placement TTFB impact CLS risk Indexing risk Use when
Around the whole page Worst Low High (whole page waits) Never, in practice
Around each data-dependent section Good Medium (manageable) Low Default choice for most pages
Around individual list items Best TTFB High if heights vary Low Long feeds, search results
No boundary (blocking) Worst None None Tiny pages, above-the-fold hero
Client-side fetch after hydration Best TTFB High High Never for rankable content

My default is the second row. One boundary per independently-fetchable section, each with a height-matched skeleton. I only go to per-item boundaries on feeds where the first item is genuinely useful on its own.

Streaming and metadata: the quiet SEO killer

This is where I've seen the most damage in production apps, and almost no tutorial covers it properly.

generateMetadata runs on the server before the shell is flushed. That's fine. But in streamed apps, people often move metadata generation into a component that depends on the same slow data as a Suspense boundary, and Next.js will block the shell on it. Your beautiful streaming architecture collapses back to a blocking render because the <title> needs a database call.

The fix is to separate concerns:

// app/blog/[slug]/page.tsx
import type { Metadata } from 'next';
import { Suspense } from 'react';
import { getPostMeta, getPostBody } from '@/lib/posts';

// Fast, cached metadata lookup. Blocks the shell, but it's cheap.
export async function generateMetadata(
  { params }: { params: Promise<{ slug: string }> }
): Promise<Metadata> {
  const { slug } = await params; // params is async in Next.js 15+
  const meta = await getPostMeta(slug); // cached, ~5ms
  return {
    title: meta.title,
    description: meta.excerpt,
    alternates: { canonical: `/blog/${slug}` },
    openGraph: { title: meta.title, images: [meta.ogImage] },
  };
}

export default async function PostPage(
  { params }: { params: Promise<{ slug: string }> }
) {
  const { slug } = await params;
  return (
    <article>
      <h1>{/* also from cached meta, or passed down */}</h1>
      <Suspense fallback={<BodySkeleton />}>
        {/* Slow body fetch streams in */}
        <PostBody slug={slug} />
      </Suspense>
    </article>
  );
}

Three rules from that snippet:

  1. Metadata must come from a fast, cached source. If generateMetadata awaits an uncached API, you've killed streaming for the entire route.
  2. Canonicals and noindex must be in the shell, not streamed. Next.js handles this correctly if you use the metadata API, but if you're injecting <link rel="canonical"> manually inside a Suspense boundary, you're asking for trouble.
  3. JSON-LD should be rendered in a server component, not injected client-side. Streamed JSON-LD works fine. Client-injected JSON-LD is often missed by crawlers on the first pass.

Structured data in streamed server components

For Article, Product, or FAQ schema, render the <script type="application/ld+json"> tag directly in the server component that holds the data. It arrives in the stream with the content and Google reads it on the same pass. (See Google's structured data documentation for the supported formats.)

export function ArticleSchema({ post }: { post: Post }) {
  const json = {
    '@context': 'https://schema.org',
    '@type': 'Article',
    headline: post.title,
    datePublished: post.publishedAt,
    author: { '@type': 'Person', name: 'Shahriar Shuvo' },
  };
  return (
    <script
      type="application/ld+json"
      dangerouslySetInnerHTML={{ __html: JSON.stringify(json) }}
    />
  );
}

Don't wrap this in Suspense unless you have a reason. It's cheap to render and you want it in the shell.

Measuring it: streaming vs blocking, side by side

I ran a comparison on a real product listing page (roughly 400 products, one Postgres query with a join, hosted on Vercel with a Singapore region close to the primary user base). Same code, same data, one flag flipped: the Suspense boundary removed so the page blocks on the query.

Metric Blocking render RSC streaming Change
TTFB (p75) 780ms 180ms -77%
FCP (p75) 1.4s 0.6s -57%
LCP (p75) 1.9s 1.1s -42%
CLS (p75) 0.02 0.08 +0.06 (fixed with height-matched skeleton)
HTML size 412KB 428KB +4%
Total blocking time 210ms 240ms +30ms

The numbers are from my own project and will vary with your data and hosting. The pattern is what matters: streaming wins on TTFB and LCP, costs slightly more bytes, and can hurt CLS if you're careless with fallbacks. After I fixed the skeleton heights, CLS went back to 0.01.

Measure with WebPageTest (its waterfall view is excellent for this), or Lighthouse with the "Timespan" mode if you want to see the streamed chunks arriving. Chrome DevTools Network panel with throttling on is honestly enough to spot the pattern.

A note on hosting and edge latency

If a chunk of your audience is in Dhaka and your server is in us-east-1, streaming helps but it doesn't beat physics. I've seen 200ms of extra RTT eat most of the streaming benefit for Bangladeshi users. Two options: deploy to an edge runtime close to the user (Vercel, Cloudflare, or a regional node), or use a CDN that caches the shell aggressively and streams the dynamic parts from a nearby origin. For clients in Australia, I default to ap-southeast-2 or Vercel's Sydney edge. For Bangladesh, Singapore is usually the sweet spot. Same logic applies for Canada and New Zealand: pick the region, not the brand. If you're weighing frameworks for an AI-enhanced build, my Next.js vs Remix vs Astro comparison for 2026 digs into how each handles this kind of rendering.

A practical debugging checklist

When a streamed Next.js page isn't indexing or is performing badly, run through this in order. I've used it on dozens of client projects and it catches most issues within twenty minutes.

  1. View Source, not Inspect. Confirm your rankable content is in the streamed HTML. If it's not there, streaming is not your problem; your data fetching is.
  2. Check generateMetadata latency. Add a timer. If it's over 50ms, cache it.
  3. Verify canonical and robots tags render in the shell. View Source at t=0 and confirm they're present before any Suspense boundary resolves.
  4. Run Google Rich Results Test on a URL. It renders with Chromium and will show you what Googlebot sees, including streamed content.
  5. Check CLS in Search Console's Core Web Vitals report. If it's above 0.1, audit your skeleton heights.
  6. Test with slow 3G throttling. Watch the waterfall. If your slowest chunk arrives after 3 seconds, either cache it or move it out of the critical path.
  7. Confirm no rankable content is behind a client-side fetch. Grep for useEffect and fetch in your page component tree.

If your streamed sections depend on AI-generated code, it's worth layering in the verification steps from my post on human oversight for AI-generated code before you ship.

FAQ

Does RSC streaming hurt SEO?

No, and it usually helps. Googlebot renders streamed HTML and waits for the stream to complete. The real risks are metadata generation blocking the shell, rankable content placed behind client-side fetches, and layout shift from poorly-sized Suspense fallbacks. Fix those three and streaming is generally better than blocking renders for SEO.

Where should I put Suspense boundaries in Next.js?

Around each independently-fetchable section that can resolve at different speeds, with a fallback that matches the height of the real content. Don't wrap the whole page in one boundary (you lose the benefit), and don't put your H1 or primary copy inside a boundary that depends on slow data.

Can I use generateMetadata with streaming?

Yes, but keep it fast. generateMetadata runs before the shell flushes, so any latency there blocks streaming for the entire route. Cache the metadata lookup aggressively (Next.js unstable_cache, Redis, or a precomputed index) and keep it under 50ms. Note that unstable_cache is being superseded by the use cache directive and cacheLife/cacheTag APIs in recent Next.js releases, so check the current Next.js caching docs for your version.

Is streaming better than static generation for SEO?

Static generation still wins on raw speed for content that rarely changes. Streaming wins for pages with personalized, slow, or partially-dynamic data. For marketing pages, use static or ISR. For dashboards, product listings with live inventory, and personalized feeds, stream. Partial Prerendering (PPR) in newer Next.js versions blends the two; it has been available as an experimental feature and is stabilizing over time, so check the Next.js PPR docs for its current status on your version.

Where this leaves you

Streaming RSC isn't a rendering trick you bolt on at the end. It's an architectural choice that changes where your content lives, when it ships, and how crawlers see it. The teams that get it right treat Suspense boundaries as SEO decisions, keep metadata on a fast path, and measure CLS like it's a real metric rather than an afterthought.

If you're building on Next.js and want a second set of eyes on your App Router architecture, or you're a founder deciding whether to hire a Next.js developer who actually understands streaming and Core Web Vitals versus one who'll ship a client-fetched SPA and call it done, that's exactly the kind of work I do. I've delivered 300+ sites and apps across Bangladesh, the USA, the UK, and Australia, and I'm happy to talk through your setup. Reach out through the contact page and tell me what you're building.

Frequently asked questions

Does RSC streaming hurt SEO in Next.js?

No, it usually helps. Googlebot renders streamed HTML and waits for the stream to complete. The real risks are slow generateMetadata blocking the shell, rankable content placed behind client-side fetches, and layout shift from badly-sized Suspense fallbacks. Fix those and streaming generally beats blocking renders on TTFB, FCP, and LCP.

Where should I put Suspense boundaries in the Next.js App Router?

Around each independently-fetchable section that can resolve at different speeds, with a fallback whose height matches the real content. Avoid one giant boundary around the whole page (you lose the streaming benefit) and never wrap your H1 or primary copy in a boundary that depends on slow data.

Can I use generateMetadata with streaming?

Yes, but it runs before the shell flushes, so any latency there blocks streaming for the whole route. Cache the metadata lookup (with unstable_cache, Redis, or a precomputed index) and keep it under 50ms. Note that unstable_cache is being superseded by the use cache directive in recent Next.js versions, so check the current docs for your version.

Is streaming better than static generation for SEO?

For content that rarely changes, static generation or ISR still wins on raw speed. Streaming wins for personalized, slow, or partially-dynamic pages like dashboards, live product listings, and feeds. Partial Prerendering (PPR) in newer Next.js versions blends both approaches; it has been experimental and is stabilizing, so verify its status for your version.

Share this post

Native Web Share is available on mobile, so that share sheet includes Instagram and any other app you have installed.

Let's Connect

Get In Touch

Let's build something premium together.

Contact info

Follow me
Chat on WhatsApp