DEV Community: Alamin Sarker

How I Fixed My React SEO Issues Using the Right Developer Tool

Alamin Sarker — Thu, 07 May 2026 09:14:41 +0000

Here's the thing nobody tells you when you start building SPAs: React renders in the browser, but Googlebot often doesn't wait long enough to see what you rendered. Your <title> tag? Empty on first load. Your meta descriptions? Missing. Your beautiful content? Invisible to crawlers.

In this article, I'll walk through the exact problems I ran into, how I diagnosed them, and the tools I used to fix them — including a lightweight npm package that saved me hours of boilerplate.

Why React Apps Struggle with SEO (The Real Reason)

Most React tutorials skip this part: when a crawler hits your React app, it receives something like this:

<!DOCTYPE html>
<html>
  <head>
    <title></title>
    <meta name="description" content="" />
  </head>
  <body>
    <div id="root"></div>
    <script src="/static/js/main.chunk.js"></script>
  </body>
</html>

That's it. An empty shell. Your JavaScript hasn't executed yet, so Google sees nothing meaningful. Even if Googlebot does eventually execute your JS (and it sometimes does), the timing is unreliable — and you have zero control over it.

There are three layers to this problem:

Dynamic <head> tags — your <title> and <meta> don't update per route
Missing structured data — no JSON-LD for rich search results
No way to audit the problem — you're flying blind without tooling

Let's fix each one.

Step 1: Make Your `<head>` Tags Dynamic Per Route

The first thing I did was stop assuming React Router alone would handle my SEO. It won't. You need a way to inject page-specific metadata into <head> on every route change.

The classic solution is react-helmet-async. Here's a reusable SEOHead component I now drop into every project:

// components/SEOHead.jsx
import { Helmet } from 'react-helmet-async';

export function SEOHead({ title, description, canonical, ogImage }) {
  return (
    <Helmet>
      <title>{title}</title>
      <meta name="description" content={description} />
      <link rel="canonical" href={canonical} />

      {/* Open Graph */}
      <meta property="og:title" content={title} />
      <meta property="og:description" content={description} />
      <meta property="og:url" content={canonical} />
      {ogImage && <meta property="og:image" content={ogImage} />}

      {/* Twitter Card */}
      <meta name="twitter:card" content="summary_large_image" />
      <meta name="twitter:title" content={title} />
      <meta name="twitter:description" content={description} />
    </Helmet>
  );
}

Use it in any page component like this:

// pages/BlogPost.jsx
import { SEOHead } from '../components/SEOHead';

export function BlogPost({ post }) {
  return (
    <>
      <SEOHead
        title={`${post.title} | My Blog`}
        description={post.excerpt}
        canonical={`https://mysite.com/blog/${post.slug}`}
        ogImage={post.coverImage}
      />
      <article>
        <h1>{post.title}</h1>
        {/* rest of content */}
      </article>
    </>
  );
}

Wrap your app with HelmetProvider at the root:

// index.jsx
import { HelmetProvider } from 'react-helmet-async';

root.render(
  <HelmetProvider>
    <App />
  </HelmetProvider>
);

Result: Every route now has accurate, unique <title> and <meta description> tags. Crawlers can read them.

Step 2: Add Structured Data Without Losing Your Mind

This is where most developers give up. Structured data (JSON-LD) unlocks rich results in Google — star ratings, breadcrumbs, article dates — but the spec is verbose and easy to get wrong.

I started using @power-seo here, not because it does magic, but because it generates validated JSON-LD schemas with a clean API instead of me copy-pasting blobs from schema.org.

npm install @power-seo

Here's how I added Article structured data to blog posts:

import { ArticleSchema } from '@power-seo';

export function BlogPost({ post }) {
  return (
    <>
      <SEOHead ... />
      <ArticleSchema
        headline={post.title}
        description={post.excerpt}
        author={{ name: post.author.name, url: post.author.profileUrl }}
        datePublished={post.publishedAt}
        dateModified={post.updatedAt}
        image={post.coverImage}
      />
      <article>...</article>
    </>
  );
}

This generates a properly formatted <script type="application/ld+json"> block in your <head>. No manual JSON wrangling, no forgetting required fields. You can validate the output instantly with Google's Rich Results Test.

For product pages, it's the same pattern with ProductSchema. For FAQs, FAQSchema. The schemas match what Google actually expects.

Step 3: Audit What Crawlers Actually See

Here's the workflow I now use before shipping any React page:

1. Google's URL Inspection Tool (Search Console) — paste your URL and click "Test Live URL." This shows you exactly what Googlebot renders, including whether your dynamic <head> tags are populated.

2. curl the raw HTML — simulates a crawler that doesn't execute JS:

curl -s https://yoursite.com/blog/some-post | grep -i '<title\|<meta name="description'

If this returns empty or generic values, you have a problem regardless of what React renders in the browser.

3. Run Lighthouse in CI — add this to your GitHub Actions workflow:

- name: Lighthouse SEO Audit
  uses: treosh/lighthouse-ci-action@v10
  with:
    urls: |
      https://yoursite.com/
      https://yoursite.com/blog/
    budgetPath: ./lighthouse-budget.json
    uploadArtifacts: true

Your lighthouse-budget.json can enforce a minimum SEO score:

[{
  "path": "/*",
  "assertions": {
    "categories:seo": ["error", { "minScore": 0.9 }]
  }
}]

Result: Your CI pipeline now fails if SEO score drops below 90. No more shipping broken metadata.

What I Learned: Key Takeaways

Never trust the browser view for SEO. Always test with curl or a crawler simulator. What you see in Chrome DevTools and what Googlebot sees can be completely different.
Dynamic <head> management is non-negotiable for SPAs. react-helmet-async is the minimum viable solution — set it up before you write your first route, not after you notice you're missing from search results.
Structured data is a multiplier, not a nice-to-have. Rich results get significantly higher click-through rates. If you're writing articles, listing products, or building FAQs, add JSON-LD from day one.
Automate the audit. Manual checks are for debugging. Lighthouse in CI is for prevention. The two hours you spend setting up automated SEO checks will save you from ranking drops you'd never notice until they hurt.

If you want to explore the structured data approach further, I wrote a more detailed breakdown here: React developer tool for SEO

Let's Talk About It

How are you handling SEO in your React apps? Are you using SSR (Next.js, Remix), pre-rendering, or making client-side rendering work with tools like these?

I'm especially curious about teams who've made pure CSR work well for SEO what's your stack look like? Drop it in the comments, genuinely interested to compare notes.

Power SEO AI vs LangChain vs Vercel AI SDK (2026 ) Guide

Alamin Sarker — Wed, 06 May 2026 10:39:08 +0000

I spent three hours debugging why Google Search Console was reporting zero indexed pages on a freshly launched Next.js app. Lighthouse score: 98. PageSpeed: fast. Meta tags: present. The culprit? Every SEO-relevant element was rendered client-side, invisible to crawlers. The fix was four lines of structured data and a properly placed <head> injection — but finding that fix took hours of manual audit work that a half-decent AI tool should have caught in seconds.

This guide compares the three most-reached-for AI SEO libraries in the JavaScript ecosystem right now: LangChain, Vercel AI SDK, and @power-seo/ai. You'll see exactly what each one produces for the same input, where each breaks down, and which one you should actually wire into a production project today.

Why JavaScript SEO is a Different Beast

Traditional SEO tools — Screaming Frog, Ahrefs site audits, even Google's own Rich Results Test — were built when the web was mostly server-rendered HTML. You fetched a URL, you got the content. Done.

Modern JavaScript apps break that assumption. A React or Vue SPA might return a <div id="root"></div> to a crawler and nothing else. Metadata lives in useEffect. Structured data gets injected after hydration. Canonical tags are set by client-side routers.

AI SEO libraries try to solve this in one of two ways:

Wrap a general LLM with SEO-flavored prompts (the LangChain / Vercel AI SDK approach)
Embed SEO logic as first-class domain knowledge rather than prompting for it on the fly

The difference sounds subtle. In practice it's the difference between getting a paragraph of advice and getting schema-valid JSON you can paste straight into your <head>.

Approach 1: LangChain — Flexible but Verbose

LangChain is the duct tape of the AI world. You can build anything with it, which also means you have to build everything yourself.

Here's a minimal SEO metadata generator with LangChain and OpenAI:

import { ChatOpenAI } from "@langchain/openai";
import { PromptTemplate } from "@langchain/core/prompts";

const model = new ChatOpenAI({ modelName: "gpt-4o" });

const seoPrompt = PromptTemplate.fromTemplate(`
  You are an SEO expert. Given this page content:
  {content}

  Return a JSON object with: title, metaDescription, ogTitle, ogDescription, canonicalUrl.
  Page URL: {url}
`);

const chain = seoPrompt.pipe(model);

const result = await chain.invoke({
  content: "Your page text here...",
  url: "https://example.com/blog/my-post",
});

console.log(result.content);

What you get: A string that looks like JSON. Sometimes it is. Sometimes it has markdown fences around it. Sometimes the field names drift (meta_description instead of metaDescription). You'll need a parsing layer, error handling, and retry logic before this is production-ready.

LangChain excels when you're building a pipeline — ingesting content, transforming it, storing embeddings. For a focused SEO audit task it's overkill and underspecified.

Approach 2: Vercel AI SDK — Ergonomic, But SEO-Agnostic

Vercel's AI SDK (ai on npm) is genuinely pleasant to use. Streaming works out of the box, the generateObject function with Zod schemas almost solves the "give me structured output" problem, and it integrates cleanly with Next.js.

import { generateObject } from "ai";
import { openai } from "@ai-sdk/openai";
import { z } from "zod";

const SeoSchema = z.object({
  title: z.string().max(60),
  metaDescription: z.string().max(160),
  structuredData: z.record(z.unknown()).optional(),
});

const { object } = await generateObject({
  model: openai("gpt-4o"),
  schema: SeoSchema,
  prompt: `Generate SEO metadata for this page: ${pageContent}`,
});

console.log(object);
// { title: "...", metaDescription: "...", structuredData: undefined }

This is cleaner than raw LangChain. The Zod schema enforces output shape, so you stop playing JSON roulette.

The gap: the SDK has no SEO domain knowledge baked in. It doesn't know Google's current title truncation threshold is ~60 characters on mobile. It doesn't generate valid Article or Product schema automatically based on page type detection. You're still writing the prompt engineering yourself — which means every developer on the team writes slightly different prompts and gets slightly different output quality.

Approach 3: @power-seo/ai — SEO Logic as a First-Class Concern

This is where @power-seo/ai takes a different stance. Instead of being a general AI wrapper you prompt for SEO, it ships with SEO-specific analyzers, validators, and generators as first-class methods.

npm install @power-seo/ai

import { analyzePage, generateMetadata } from "@power-seo/ai";

// Audit an existing page
const audit = await analyzePage({
  url: "https://yoursite.com/blog/my-post",
  renderMode: "spa", // tells the analyzer to evaluate post-hydration DOM
});

console.log(audit.issues);
// [
//   { severity: "high", rule: "title-length", message: "Title is 78 chars — truncates on mobile" },
//   { severity: "medium", rule: "structured-data-missing", type: "BlogPosting" },
// ]

// Generate drop-in metadata
const meta = await generateMetadata({
  content: pageContent,
  pageType: "article",
  baseUrl: "https://yoursite.com",
});

console.log(meta.jsonLd);
// Valid JSON-LD ready to inject into <script type="application/ld+json">

The renderMode: "spa" flag is the detail that saves you hours. It runs the audit against the hydrated DOM, not the raw HTML response — which is exactly the class of bug that had me staring at Search Console for three hours.

The output is deterministic and schema-valid by construction, not by prompt luck. You can drop meta.jsonLd straight into a Next.js layout.tsx without parsing or sanitizing.

A deeper writeup on the architecture behind this, including how it handles dynamic routes and ISR pages, is at AI SEO library JavaScript.

What I Actually Learned

General LLMs don't have SEO opinions — they have SEO words. If you prompt GPT-4 for SEO help, you get correct-sounding output that may quietly fail Google's current guidelines. Grounding the AI in actual rules (title length, schema types, crawlability signals) changes the output quality dramatically.
Structured output (Zod + Vercel AI SDK) is table stakes in 2026 — if you're still parsing freeform LLM strings for anything going into production, stop. generateObject with a schema should be the baseline.
SPA render mode matters more than people admit — most AI SEO tools audit the server response. Your users (and Google's crawler) see the post-hydration DOM. These are not the same page.
Pick the tool that matches your actual workflow — if you're building a content pipeline, LangChain. If you're building Next.js features, Vercel AI SDK. If you're specifically solving JavaScript SEO problems, reach for something with SEO domain logic already embedded.

The @power-seo/ai package is also on npm: npmjs.com/package/@power-seo/ai

Let's Talk About This

Here's the thing I'm genuinely curious about: why is SEO analysis for JavaScript websites fundamentally different from traditional SEO — and do you think most developers actually understand that gap?

In my experience, most JS developers treat SEO as a <meta> tag problem and call it solved. But the crawlability issue runs deeper. Have you run into weird SEO gaps in your own React or Next.js projects? What's your current toolchain for catching them before they hit production? Drop a comment I read every one.

SEO Mistakes in 2026: How I Fixed Them Using the Power SEO Toolkit

Alamin Sarker — Tue, 05 May 2026 08:53:05 +0000

Introduction: Why SEO still fails in 2026

Even in 2026, most websites don’t fail because of bad content—they fail because of small SEO mistakes that compound over time.

I’ve seen sites with:

Good design
Good content
Good performance

…still not ranking properly.

The reason is simple: SEO mistakes in 2026 are mostly technical, not content-only problems.

In this article, I’ll show how I fixed these issues using the Power SEO Toolkit in real-world projects.

1. Technical SEO mistakes (Crawlability issues)

One of the biggest SEO mistakes in 2026 is ignoring how search engines crawl your site.

If Google can’t properly crawl your pages, nothing else matters.

Common problems:

Missing sitemap
Broken internal routes
Wrong redirects
Orphan pages

Fix: Auto-generate sitemap

Instead of manually managing XML sitemaps, I used a simple utility from the toolkit:

npm install @power-seo/sitemap

Example usage:

import { generateSitemap } from '@power-seo/sitemap';

const xml = generateSitemap({
  hostname: 'https://example.com',
  urls: [
    { loc: '/', priority: 1.0 },
    { loc: '/blog', priority: 0.8 },
  ],
});

This removes one of the most common SEO mistakes in 2026: outdated or broken sitemap structure.

2. Meta tags and SERP display mistakes

Many developers still ignore how pages appear on Google.

This leads to:

Missing meta descriptions
Truncated titles
Weak CTR

These are silent SEO mistakes in 2026 that directly affect traffic.

Fix: Standardized meta generation

npm install @power-seo/meta

Example:

import { createMetadata } from '@power-seo/meta';

export const metadata = createMetadata({
  title: 'SEO Guide for 2026',
  description: 'Fix modern SEO mistakes using structured tools and best practices.',
});

This ensures every page is properly optimized for SERP display.

3. Poor content optimization mistakes

Another major SEO mistake in 2026 is writing content without structure or keyword alignment.

Problems:

Weak keyword placement
No structure
Thin content
No readability check

Fix: Content analysis tool

npm install @power-seo/content-analysis

Example:

import { analyzeContent } from '@power-seo/content-analysis';

const result = analyzeContent({
  title: 'SEO Mistakes in 2026',
  content: htmlContent,
  focusKeyphrase: 'SEO mistakes in 2026',
});

console.log(result.score);

This helps detect SEO mistakes before publishing.

4. Image SEO mistakes

Many sites still ignore image optimization.

Common issues:

Missing alt text
Large images
Wrong formats

These are easy SEO mistakes in 2026 but heavily impact Core Web Vitals.

Fix:

npm install @power-seo/images

Example:

import { analyzeAltText } from '@power-seo/images';

const issues = analyzeAltText(images, 'SEO');
console.log(issues);

5. Internal linking mistakes

One of the most overlooked SEO mistakes in 2026 is orphan pages.

Pages without internal links = invisible pages.

Fix:

npm install @power-seo/links

Example:

import { findOrphanPages } from '@power-seo/links';

const orphans = findOrphanPages(graph);
console.log(orphans);

This ensures no page is left unindexed.

6. Structured data mistakes

Without schema, your pages lose rich results.

Common SEO mistake:

No JSON-LD
Invalid schema
Missing FAQ/Product markup

Fix:

npm install @power-seo/schema

Example:

import { article } from '@power-seo/schema';

const schema = article({
  headline: 'SEO Mistakes in 2026',
  description: 'Fixing SEO mistakes using structured tools.',
});

7. Not measuring SEO performance

Many developers fix SEO but never measure results.

That’s another hidden SEO mistake in 2026.

Fix:

npm install @power-seo/analytics

This helps connect:

GSC data
SEO audit score
traffic performance

Conclusion: Fix SEO mistakes systematically, not manually

The biggest lesson I learned:

SEO mistakes in 2026 are not about knowledge — they are about consistency.

Instead of manually checking everything, I now:

automate audits
validate content before publishing
enforce SEO rules in CI
track performance continuously

The result is simple:
fewer SEO mistakes
better rankings
consistent organic traffic

From Chaos to Control: How Smart Brands Automate Consistency

Alamin Sarker — Mon, 04 May 2026 07:53:06 +0000

Maintaining a strong and consistent brand used to be one of the most manual, time-consuming parts of marketing. Different teams created different visuals, freelancers interpreted guidelines in their own way, and over time the brand slowly drifted into inconsistency.

That’s the chaos most growing businesses experience.

In 2026, the companies solving this problem are not working harder—they are working smarter through Automated Branding.

This shift is changing how brands are built, managed, and scaled. Instead of relying on constant human oversight, smart systems now ensure that every piece of content—design, copy, campaigns, and assets—stays aligned with a unified identity.

What Is Automated Branding?

Automated Branding is the use of AI systems, design tools, and workflow automation to maintain brand consistency across all marketing channels without manual checking at every step.

It goes beyond traditional branding guidelines. Instead of storing rules in static documents, brands now turn them into living systems that actively guide content creation.

This means:

Designs automatically follow brand colors and typography
AI generates content aligned with tone of voice
Marketing assets stay consistent across all channels
Brand rules are enforced in real time

In short, Automated Branding transforms branding from a manual process into a scalable system.

Why Brand Consistency Is So Hard Today

Modern brands operate across multiple platforms at the same time:

Social media channels
Paid advertising
Websites and landing pages
Email campaigns
Offline materials and packaging

Each channel often involves different people or teams. Without a central system, inconsistency becomes inevitable.

Common problems include:

Slightly different logo usage
Off-brand colors in social posts
Inconsistent tone of voice
Multiple versions of the same campaign
Lack of visibility across teams

This creates confusion in the audience’s mind—and weakens trust over time.

How Automated Branding Solves the Problem

The goal of Automated Branding is simple:
remove inconsistency before it happens.

Instead of reviewing everything manually, automation builds guardrails into the system itself.

Here’s how smart brands achieve this:

1. Living Brand Systems Instead of Static Guidelines

Traditional brand guidelines are usually PDFs that teams rarely follow in detail.

Modern brands replace them with live brand systems that integrate directly into tools like design platforms and content workflows.

This ensures:

Only approved fonts and colors are available
Templates automatically match brand identity
Teams cannot accidentally break visual rules

2. AI-Powered Content Creation

AI tools now generate marketing assets based on predefined brand rules.

This includes:

Social media posts
Ad creatives
Blog visuals
Email templates

Instead of starting from scratch, teams generate first drafts that are already on-brand. This reduces revisions and speeds up production significantly.

3. Automated Brand Compliance Checks

One of the most powerful parts of Automated Branding is real-time validation.

Before content goes live, systems can automatically check:

Logo placement
Color accuracy
Typography rules
Tone consistency in copy

If something is off, it gets flagged instantly—no manual review bottleneck needed.

4. Connected Marketing Workflows

Automated Branding works best when connected with marketing workflows.

This means:

Content creation → automated approval → scheduling → publishing
Every step follows brand rules
Teams focus on strategy instead of repetitive checking

This creates a smooth production pipeline where consistency is built in, not added later.

The Business Impact of Automated Branding

Brands that adopt automation are seeing major improvements:

Faster content production cycles
Fewer design and revision errors
Stronger brand recognition
More consistent customer experience
Reduced workload for marketing teams

Most importantly, it allows brands to scale without losing identity.

Whether a company is managing 5 people or 500 locations, the system ensures everything still feels like one unified brand.

Tools That Enable Automated Branding

Modern Automated Branding systems often include:

Design platforms with built-in brand kits
AI content generation tools
Marketing automation software
Digital asset management systems
Brand compliance platforms

These tools work together to create a fully connected branding ecosystem.

Human + AI: The Right Balance

A common misconception is that Automated Branding removes the human role. In reality, it shifts it.

Humans still control:

Brand strategy
Creative direction
Final approvals for key campaigns

AI handles:

Repetitive design enforcement
Content generation drafts
Consistency checks
Workflow automation

The best results come from combining both—not replacing one with the other.

Conclusion: From Chaos to Control

Brand inconsistency is no longer just a design problem—it’s a systems problem.

Automated Branding gives companies a way to move from scattered execution to structured control. Instead of constantly fixing mistakes, brands can prevent them entirely through automation.

The result is simple but powerful:

A brand that looks, feels, and sounds consistent everywhere—without requiring constant manual effort.

In a competitive market, that level of consistency isn’t just helpful. It’s a major advantage.

Power SEO Content Analysis Review for Developers

Alamin Sarker — Sun, 03 May 2026 10:45:25 +0000

Your React app looks beautiful. Your Lighthouse score is 98. But Google still can't rank your content and you have no idea why.

Most developers treat SEO like a mysterious black box: you write good content, add some meta tags, and hope for the best. The real problem is we're not measuring the right things at the right time. In this article, I'll show you how to build an automated SEO content analysis pipeline in your existing Node.js workflow — auditing keyword density, readability scores, and structured metadata — and where @power-seo/content-analysis fits into that picture without replacing your own judgment.

The Problem: What Crawlers See vs. What You See

Here's the counterintuitive thing: Google doesn't see your beautifully rendered React app. It sees the raw HTML returned by the server — or whatever the client-side renderer manages to output before the crawl budget runs out.

Run this and prepare to be humbled:

curl -A "Googlebot/2.1 (+http://www.google.com/bot.html)" https://your-site.com/your-page

Compare that output to what your browser renders. If you're using client-side rendering with no SSR or prerendering, you'll likely see a near-empty <body>. All that beautiful copy your content team wrote? Invisible to the crawler.

The fix is straightforward — but you need to measure the problem first before you can confirm the solution:

// check-ssr.mjs
import fetch from 'node-fetch';

const GOOGLEBOT_UA = 'Googlebot/2.1 (+http://www.google.com/bot.html)';

async function checkCrawlability(url) {
  const res = await fetch(url, {
    headers: { 'User-Agent': GOOGLEBOT_UA }
  });
  const html = await res.text();

  const bodyTextLength = html
    .replace(/<[^>]+>/g, '')
    .replace(/\s+/g, ' ')
    .trim().length;

  console.log(`URL: ${url}`);
  console.log(`Status: ${res.status}`);
  console.log(`Visible text characters: ${bodyTextLength}`);
  console.log(bodyTextLength < 500 ? '⚠️  Low content — possible CSR issue' : '✅ Content looks crawlable');
}

checkCrawlability('https://your-site.com/your-page');

Result: If bodyTextLength comes back under 500 characters and your page has 1,200+ words, you have a rendering problem — not an SEO problem. Fix the rendering first. Everything else is noise until then.

Automating Keyword Density and Readability Audits

Once your content is actually crawlable, the next layer is content quality signals. Google's ranking algorithm weighs keyword relevance, heading structure, content depth, and readability — and none of these are visible in your dev tools unless you instrument for them.

Here's a minimal audit script you can drop into any project:

// seo-audit.mjs
import { JSDOM } from 'jsdom';
import fetch from 'node-fetch';

function countWords(text) {
  return text.trim().split(/\s+/).filter(Boolean).length;
}

function keywordDensity(text, keyword) {
  const words = text.toLowerCase().split(/\s+/);
  const kw = keyword.toLowerCase();
  const matches = words.filter(w => w.includes(kw)).length;
  return ((matches / words.length) * 100).toFixed(2);
}

function fleschReadingEase(text) {
  const sentences = text.split(/[.!?]+/).filter(Boolean).length;
  const words = countWords(text);
  const syllables = text
    .toLowerCase()
    .replace(/[^a-z\s]/g, '')
    .split(/\s+/)
    .reduce((acc, word) => acc + (word.match(/[aeiouy]+/g) || []).length, 0);

  return (
    206.835 -
    1.015 * (words / sentences) -
    84.6 * (syllables / words)
  ).toFixed(1);
}

async function auditPage(url, targetKeyword) {
  const res = await fetch(url);
  const html = await res.text();
  const dom = new JSDOM(html);
  const doc = dom.window.document;

  const title = doc.querySelector('title')?.textContent ?? 'MISSING';
  const metaDesc = doc.querySelector('meta[name="description"]')?.getAttribute('content') ?? 'MISSING';
  const h1s = [...doc.querySelectorAll('h1')].map(h => h.textContent.trim());
  const bodyText = doc.body?.textContent ?? '';

  const wordCount = countWords(bodyText);
  const density = keywordDensity(bodyText, targetKeyword);
  const readability = fleschReadingEase(bodyText);

  return {
    url,
    title,
    titleLength: title.length,
    metaDesc,
    metaDescLength: metaDesc.length,
    h1Count: h1s.length,
    h1s,
    wordCount,
    keywordDensity: `${density}%`,
    readabilityScore: readability,
    readabilityLabel: readability > 60 ? 'Easy' : readability > 30 ? 'Moderate' : 'Difficult'
  };
}

// Run it
const report = await auditPage(
  'https://your-site.com/your-blog-post',
  'seo content analysis'
);

console.log(JSON.stringify(report, null, 2));

Sample output:

{
  "url": "https://your-site.com/your-blog-post",
  "title": "Power SEO Content Analysis for Developers",
  "titleLength": 42,
  "metaDesc": "Learn how to audit your content...",
  "metaDescLength": 68,
  "h1Count": 1,
  "wordCount": 1247,
  "keywordDensity": "1.42%",
  "readabilityScore": "58.3",
  "readabilityLabel": "Easy"
}

Sweet spots to aim for: title 50–60 chars, meta description 120–160 chars, one H1, keyword density 1–2%, Flesch score above 50 for general audiences.

Where a Dedicated Tool Fits: `@power-seo/content-analysis` vs `seo-analyzer`

Writing the script above is instructive — you understand exactly what's being measured. But once you're auditing dozens of pages, or you want Yoast-style scoring with React components baked in, you want something with more depth out of the box.

This is where @power-seo/content-analysis vs seo-analyzer comparisons become relevant for real workflows. I tested @power-seo/content-analysis — part of the 17-package @power-seo ecosystem from ccbd.dev — against both a hand-rolled approach and the older seo-analyzer package for a content-heavy Next.js project.

npm install @power-seo/content-analysis

The package is a Yoast-style content analysis engine: it runs a battery of checks (keyword in title, meta description length, heading hierarchy, readability score, content depth) and returns a structured score with per-check results. Critically, it also ships React components, so you can surface the same analysis live in an editor UI without wiring up a separate API.

// content-analysis-check.mjs
import { analyzeContent } from '@power-seo/content-analysis';

const result = analyzeContent({
  html: '<h1>Power SEO Content Analysis</h1><p>Your article body...</p>',
  keyword: 'seo content analysis',
  meta: {
    title: 'Power SEO Content Analysis for Developers',
    description: 'A practical guide to automating SEO content analysis in Node.js.'
  }
});

console.log(result.score);        // e.g. 78
console.log(result.checks);       // array of { id, label, status, advice }
console.log(result.readability);  // Flesch-Kincaid score + label

/*
  Sample output:
  score: 78
  checks: [
    { id: 'keyword-in-title',   status: 'good',    advice: 'Keyword found in title.' },
    { id: 'meta-desc-length',   status: 'good',    advice: 'Meta description is 71 chars — within range.' },
    { id: 'keyword-density',    status: 'ok',      advice: 'Density 1.3% — within 1–2% target.' },
    { id: 'content-length',     status: 'improve', advice: 'Content is 620 words. Aim for 900+.' },
  ]
  readability: { score: 58.3, label: 'Easy' }
*/

Where it earns its place over a hand-rolled script: the structured checks array integrates directly into CI assertions (fail the build if any check is 'bad'), and the React components mean a content editor can get live feedback in the CMS without you building a separate scoring UI. Compared to seo-analyzer, which is DOM-rule-based and focused on HTML structure defects, @power-seo/content-analysis skews toward content quality signals — keyword coverage, readability, and depth — which maps more closely to what on-page SEO practitioners actually want to tune.

The full breakdown is documented at — worth reading if you're deciding between the two for a larger audit pipeline. The npm package is at power-seo content-analysis.

Plugging Audits Into Your CI Pipeline

The real unlock is making this part of your build — not a manual monthly task.

# .github/workflows/seo-audit.yml
name: SEO Content Audit

on:
  pull_request:
    paths:
      - 'content/**'
      - 'pages/**'

jobs:
  audit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '20'
      - run: npm ci
      - name: Run SEO audit
        run: node scripts/seo-audit.mjs
        env:
          AUDIT_URL: ${{ secrets.STAGING_URL }}
          TARGET_KEYWORD: ${{ vars.PRIMARY_KEYWORD }}
      - name: Fail if readability < 30
        run: |
          SCORE=$(node -e "const r = require('./seo-report.json'); console.log(r.readabilityScore)")
          if (( $(echo "$SCORE < 30" | bc -l) )); then
            echo "❌ Readability score too low: $SCORE"
            exit 1
          fi

Now a readability regression or a missing meta description blocks the merge. No one writes <title>Untitled</title> when the CI is watching.

What I Learned

Rendering is prerequisite, not optional. No amount of content optimization matters if Googlebot can't read your page. Check crawlability before anything else.
Keyword density is a signal, not a target. Chasing exactly 1.5% will ruin your prose. Aim for the range and let natural writing get you there.
Automate the measurable, human-review the rest. Scripts catch missing meta tags and thin content reliably. Judging whether your intro is actually compelling? That's still on you.
Competitor TF-IDF diffs are underused. Comparing your semantic coverage against ranking pages is more actionable than most on-page checklists. It tells you what to add, not just what's broken.

Let's Talk About It

Here's something worth discussing: why is SEO analysis for JavaScript-heavy websites fundamentally different from traditional SEO tools designed for static HTML?

Most SEO analyzers were built assuming the HTML you get from curl is the HTML Google sees. That's simply not true anymore for SPAs and hybrid-rendered apps. How have you handled this gap in your own projects — prerendering, SSR, dynamic rendering with a headless browser? Drop your approach in the comments. Genuinely curious what's working in production.

How to Rank Next.js Apps in Google: Full SEO Guide for 2026

Alamin Sarker — Sat, 02 May 2026 10:46:30 +0000

I spent an entire afternoon wondering why my freshly deployed Next.js app wasn't showing up in Google Search — not even for its own brand name. Turns out, I was server-rendering the shell but client-rendering all the meaningful content. Google saw a blank <div id="__next"></div> and moved on. The fix was restructuring a single page.tsx and adding 6 lines of metadata config. This guide covers everything I wish I'd known: metadata, dynamic OG tags, structured data, and automated auditing — all with copy-paste-ready code.

Why Next.js SEO Is a Different Beast

Traditional SEO wisdom assumes the server delivers complete HTML. Next.js gives you four rendering strategies — SSG, SSR, ISR, and CSR — and only some of them are Google-friendly by default.

Google's crawler can execute JavaScript, but it processes pages in a two-wave system. The first wave indexes raw HTML. The second wave (days later) renders JavaScript. If your <title>, meta description, and canonical tags live inside a useEffect, you're invisible until wave two — and sometimes wave two never comes for low-priority pages.

The baseline rule: anything Google needs to understand your page must be in the initial HTML response.

Next.js 14+ makes this straightforward with the Metadata API. Here's the correct pattern:

// app/blog/[slug]/page.tsx
import { Metadata } from 'next';

type Props = {
  params: { slug: string };
};

// This runs on the SERVER — output lands in the initial HTML
export async function generateMetadata({ params }: Props): Promise<Metadata> {
  const post = await fetchPost(params.slug); // your data fetcher

  return {
    title: post.title,
    description: post.excerpt,
    alternates: {
      canonical: `https://your-site.com/blog/${params.slug}`,
    },
    openGraph: {
      title: post.title,
      description: post.excerpt,
      url: `https://your-site.com/blog/${params.slug}`,
      type: 'article',
      publishedTime: post.publishedAt,
      images: [{ url: post.ogImage, width: 1200, height: 630 }],
    },
  };
}

export default async function BlogPost({ params }: Props) {
  const post = await fetchPost(params.slug);
  return <article dangerouslySetInnerHTML={{ __html: post.content }} />;
}

Result: Every blog post gets a unique <title>, description, canonical URL, and OG image — all in the initial HTML, all crawlable on wave one.

Structured Data: The Part Most Developers Skip

Rich results (star ratings, FAQs, breadcrumbs in SERPs) come from structured data. Most Next.js tutorials stop at meta tags and never touch this. That's leaving SERP real estate on the table.

Add a JSON-LD component — don't use a third-party library for this, it's 20 lines of code:

// components/JsonLd.tsx
type JsonLdProps = {
  data: Record<string, unknown>;
};

export function JsonLd({ data }: JsonLdProps) {
  return (
    <script
      type="application/ld+json"
      dangerouslySetInnerHTML={{ __html: JSON.stringify(data) }}
    />
  );
}

Then use it in your page:

// app/blog/[slug]/page.tsx
import { JsonLd } from '@/components/JsonLd';

export default async function BlogPost({ params }: Props) {
  const post = await fetchPost(params.slug);

  const articleSchema = {
    '@context': 'https://schema.org',
    '@type': 'Article',
    headline: post.title,
    description: post.excerpt,
    author: {
      '@type': 'Person',
      name: post.authorName,
      url: `https://your-site.com/authors/${post.authorSlug}`,
    },
    datePublished: post.publishedAt,
    dateModified: post.updatedAt,
    image: post.ogImage,
    publisher: {
      '@type': 'Organization',
      name: 'Your Site',
      logo: { '@type': 'ImageObject', url: 'https://your-site.com/logo.png' },
    },
  };

  return (
    <>
      <JsonLd data={articleSchema} />
      <article dangerouslySetInnerHTML={{ __html: post.content }} />
    </>
  );
}

Test it with Google's. If your schema is valid, you'll see it eligible for enhanced SERP features within a few index cycles.

Dynamic Sitemaps and Robots.txt (The Right Way)

A static sitemap.xml file is a maintenance nightmare. Every time you add a page, you forget to update it. Next.js has built-in support for dynamic sitemaps — use it:

// app/sitemap.ts
import { MetadataRoute } from 'next';

export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
  const posts = await fetchAllPosts(); // your CMS/DB call

  const blogUrls = posts.map(post => ({
    url: `https://your-site.com/blog/${post.slug}`,
    lastModified: new Date(post.updatedAt),
    changeFrequency: 'weekly' as const,
    priority: 0.8,
  }));

  return [
    {
      url: 'https://your-site.com',
      lastModified: new Date(),
      changeFrequency: 'daily',
      priority: 1,
    },
    {
      url: 'https://your-site.com/blog',
      lastModified: new Date(),
      changeFrequency: 'daily',
      priority: 0.9,
    },
    ...blogUrls,
  ];
}

// app/robots.ts
import { MetadataRoute } from 'next';

export default function robots(): MetadataRoute.Robots {
  return {
    rules: [
      {
        userAgent: '*',
        allow: '/',
        disallow: ['/api/', '/admin/', '/_next/'],
      },
    ],
    sitemap: 'https://your-site.com/sitemap.xml',
  };
}

Next.js serves these at /sitemap.xml and /robots.txt automatically — no extra configuration needed.

Automating SEO Audits Before You Deploy

The three sections above fix known problems. But what about the ones you don't know about yet — a page where someone accidentally removed the canonical, or a dynamic route where the OG image URL is malformed?

This is where automated auditing earns its keep. I wired @power-seo/analytics into my pre-deploy script to catch regressions before they hit production:

npm install @power-seo/analytics --save-dev

// scripts/seo-audit.mjs
import { auditPage } from '@power-seo/analytics';

const criticalPages = [
  'https://staging.your-site.com/',
  'https://staging.your-site.com/blog',
  'https://staging.your-site.com/blog/your-latest-post',
  'https://staging.your-site.com/pricing',
];

const results = await Promise.all(
  criticalPages.map(url =>
    auditPage(url, {
      checkCanonical: true,
      checkStructuredData: true,
      checkOpenGraph: true,
    })
  )
);

const failures = results.filter(r => r.score < 85);

if (failures.length > 0) {
  console.error('\n❌ SEO audit failed:\n');
  failures.forEach(f => {
    console.error(`  ${f.url} — Score: ${f.score}/100`);
    f.issues.forEach(issue => console.error(`    ✗ ${issue.message}`));
  });
  process.exit(1);
}

console.log('All pages passed SEO audit');

Add it to your package.json:

{
  "scripts": {
    "build": "next build",
    "seo:audit": "node scripts/seo-audit.mjs",
    "predeploy": "npm run build && npm run seo:audit"
  }
}

Now a broken canonical or missing OG tag fails the deploy before it ever reaches production. I've written up the full configuration options and CI integration at Next.js SEO if you want to go deeper.

What I Learned

Rendering strategy is an SEO decision, not just a performance one. If a page needs to rank, it needs SSG or SSR. CSR pages are invisible on wave one.
The Next.js Metadata API is not optional. <head> tags managed by useEffect or third-party libraries inside client components will not be in the initial HTML consistently.
Structured data is underused by developers and rewarded by Google. Twenty lines of JSON-LD can unlock rich results that improve CTR significantly.
Treat SEO like you treat type safety — catch regressions automatically, not manually after the fact.

Let's Talk

Why is SEO analysis for JavaScript websites different from traditional SEO? Is it the two-wave crawling, the hydration timing, the client-side routing — or something else that's bitten you specifically?

Drop your war story in the comments. I'm especially curious whether anyone has hit the wave-two delay in production and how long it actually took Google to render their JS-heavy pages.

Why JavaScript SEO Fails and How to Fix It: A Deep Dive into Modern SEO Analysis

Alamin Sarker — Mon, 27 Apr 2026 09:56:48 +0000

I spent 3 hours debugging why Google couldn't see my React app. The fix was 4 lines of code. But finding which 4 lines? That was the painful part — because the app looked perfect in my browser, passed Lighthouse, and even returned a 200 status. Google was still indexing an empty shell. If you've shipped a JavaScript-heavy app and wondered why your rankings don't match your traffic, this one's for you.

By the end of this article, you'll know why Googlebot treats your SPA differently than your users do, how to detect rendering gaps programmatically, and how to verify your fixes actually worked.

Why Googlebot Isn't Your User

Your browser is eager. It downloads HTML, kicks off a JavaScript runtime, fetches data, renders components, and paints a beautiful page — all in a blink. Googlebot is patient, but it operates on a budget.

Google uses a headless Chromium-based renderer, but the crawl queue, render queue, and index queue are separate. A page might get crawled (HTML downloaded) days before it gets rendered (JavaScript executed). During that window, if your content only exists in JavaScript-land, Google sees nothing indexable.

That curl with a Googlebot user-agent string is your fastest sanity check. If the HTML response doesn't contain your <title>, <meta description>, or primary content — you have a JavaScript SEO problem. Full stop.

Detecting the Real Problem Programmatically

Manual curl checks don't scale. Once you have 50+ routes, you need a way to diff what the server sends versus what a real browser renders.

Here's a Node.js script that does exactly that using Puppeteer:

// seo-diff.js
import puppeteer from "puppeteer";
import fetch from "node-fetch";

async function compareRendering(url) {
  // Raw HTML (what Googlebot sees on first pass)
  const rawRes = await fetch(url, {
    headers: { "User-Agent": "Googlebot" },
  });
  const rawHtml = await rawRes.text();

  // Rendered HTML (what Chromium sees after JS runs)
  const browser = await puppeteer.launch({ headless: "new" });
  const page = await browser.newPage();
  await page.goto(url, { waitUntil: "networkidle0" });
  const renderedHtml = await page.content();
  await browser.close();

  // Compare key SEO signals
  const signals = ["title", "meta[name='description']", "h1", "main", "article"];
  const results = {};

  for (const selector of signals) {
    const inRaw = rawHtml.includes(`<${selector.split("[")[0]}`);
    const inRendered = renderedHtml.includes(`<${selector.split("[")[0]}`);
    results[selector] = { raw: inRaw, rendered: inRendered, gap: !inRaw && inRendered };
  }

  return results;
}

// Run it
compareRendering("https://yoursite.com/product/123").then(console.table);

Run this across your critical routes. Any row where gap: true is a page where your content exists in the rendered DOM but not in the raw HTML — meaning Googlebot's first-pass crawl misses it entirely.

The Three Most Common Fixes (and When to Use Each)

Once you've confirmed the gap, you have three realistic options:

1. Server-Side Rendering (SSR) — The nuclear option. Works for everything, adds infra complexity. Use Next.js, Nuxt, or SvelteKit. The getServerSideProps or load functions run on the server before the HTML is sent.

2. Static Generation (SSG) — Pre-render at build time. Perfect for content that doesn't change per-user. Zero runtime cost.

3. Dynamic Rendering — Serve a pre-rendered version to crawlers only. Good for legacy SPAs you can't fully migrate. Ugly, but pragmatic.

For SSR in Next.js, the diff is straightforward:

// Before: client-side fetch (Googlebot sees nothing)
export default function ProductPage() {
  const [product, setProduct] = useState(null);
  useEffect(() => {
    fetch("/api/product/123").then(r => r.json()).then(setProduct);
  }, []);
  return <h1>{product?.name ?? "Loading..."}</h1>;
}

// After: SSR (Googlebot sees full content in raw HTML)
export async function getServerSideProps({ params }) {
  const product = await fetchProduct(params.id);
  return { props: { product } };
}

export default function ProductPage({ product }) {
  return <h1>{product.name}</h1>;
}

Those four lines in getServerSideProps are the fix I referenced at the top. Simple in hindsight. Invisible until you know what to look for.

Validating Fixes at Scale with Structured SEO Audits

Fixing one route is satisfying. Knowing your entire site is clean is better. This is where a structured audit loop pays off.

I've been using @power-seo as part of my CI pipeline for exactly this — it runs programmatic SEO checks and surfaces rendering gaps, missing meta tags, and structured data issues across routes automatically, without you having to write the Puppeteer boilerplate from scratch every time.

npx @power-seo audit --url https://yoursite.com --routes ./routes.json

The routes.json is just an array of paths. The audit runs headless Chromium against each, diffs raw vs. rendered HTML, and outputs a structured report you can fail CI on. Not magic — it's the same logic as our script above, packaged for repeatable use.

For a deeper walkthrough of how it handles JavaScript-heavy audits specifically, the team behind it published a solid breakdown here: ccbd.dev/blog/seo-analysis-for-javascript-auditing-and-ranking-modern-web-apps

What I Learned (The Hard Way)

"It works in the browser" means nothing for SEO. Always check raw HTML with a Googlebot user-agent. Your browser lies to you — kindly, but consistently.
Lighthouse won't catch rendering gaps. Lighthouse runs with JavaScript enabled. It'll give you a green score on a page Googlebot can't index. Use curl and Puppeteer diffs as your real check.
SSR isn't always the answer. For truly dynamic, authenticated content, dynamic rendering is a legitimate strategy. Don't burn a sprint migrating to SSR for a dashboard that's behind a login wall anyway.
Audit continuously, not once. Routes get added, components get refactored, and client-side fetches sneak back in. Add SEO diff checks to your CI pipeline the same way you'd add unit tests. Regressions happen silently otherwise.

Let's Talk About It

Here's a genuine question I'd love to hear your take on:

Why is SEO analysis for JavaScript websites fundamentally different from traditional SEO — and do you think Google will ever fully close the rendering gap?

I've seen teams spend months chasing ranking improvements through content and backlinks while their pages were literally invisible to crawlers. Drop your war stories, hot takes, or questions below. Especially curious if anyone's found a clean way to handle SSR for heavily interactive dashboards without losing the SPA feel.

Fixing Common SEO Mistakes with the Power SEO Toolkit (Developer Guide

Alamin Sarker — Sat, 25 Apr 2026 12:30:01 +0000

I spent 3 hours debugging why Google couldn't crawl my React app. No 404s, no console errors, nothing obviously broken. The culprit? A missing <title> tag, a robots meta set to noindex from a staging environment I'd forgotten to revert, and a canonical URL pointing to http:// instead of https://. Three separate mistakes. Four lines of code to fix them. Zero obvious symptoms while I was building.

If you've ever shipped a site and wondered why it isn't ranking — even when the content is solid — there's a good chance you're living with quiet SEO mistakes right now. This guide walks through the most common ones, how to detect them programmatically, and how to fix them before they cost you traffic.

Mistake #1: Your `<head>` Is a Disaster and You Don't Know It

The most common SEO mistake in SPAs (React, Next.js, Remix) is inconsistent or missing meta tags across dynamic routes. The homepage looks fine. The blog post at /blog/some-slug? No description, wrong canonical, og:title still says your app name.

You can audit this manually with a quick Node script:

// audit-meta.js — run with Node.js
// Usage: node audit-meta.js https://yoursite.com/some-page

const https = require("https");
const url = process.argv[2];

if (!url) {
  console.error("Usage: node audit-meta.js <url>");
  process.exit(1);
}

https.get(url, (res) => {
  let data = "";
  res.on("data", (chunk) => (data += chunk));
  res.on("end", () => {
    const checks = {
      title: /<title>(.+?)<\/title>/i.exec(data)?.[1] || "❌ MISSING",
      description:
        /name="description" content="(.+?)"/i.exec(data)?.[1] || "❌ MISSING",
      canonical:
        /rel="canonical" href="(.+?)"/i.exec(data)?.[1] || "❌ MISSING",
      robots:
        /name="robots" content="(.+?)"/i.exec(data)?.[1] ||
        "✅ Not set (defaults to index)",
      ogTitle:
        /property="og:title" content="(.+?)"/i.exec(data)?.[1] || "❌ MISSING",
    };

    console.log("\n🔍 SEO Meta Audit for:", url);
    console.table(checks);
  });
}).on("error", (e) => console.error("Request failed:", e.message));

Or if you're on Next.js App Router and want a proper solution that scales, @power-seo/meta gives you SSR-safe meta helpers that work per-route without the boilerplate:

npm install @power-seo/meta @power-seo/react

// app/blog/[slug]/page.jsx
import { buildMeta } from "@power-seo/meta";

export async function generateMetadata({ params }) {
  const post = await getPost(params.slug);

  return buildMeta({
    title: post.title,
    description: post.excerpt,
    canonical: `https://yoursite.com/blog/${params.slug}`,
    openGraph: {
      title: post.title,
      description: post.excerpt,
      image: post.coverImage,
    },
  });
}

Every route now gets correct, complete metadata — and buildMeta handles the edge cases (trailing slashes, http→https, og fallbacks) that you'd otherwise hand-roll and eventually get wrong.

Mistake #2: Broken or Missing Structured Data

Structured data (JSON-LD) is what powers rich results — star ratings, FAQs, breadcrumbs, article publish dates. Most developers skip it entirely, or add it once to the homepage and forget it exists.

The brutal part: malformed JSON-LD doesn't throw an error. It silently fails. You won't know until you check Google Search Console weeks later and notice zero rich results.

Here's the correct raw JSON-LD for an Article page, which you can drop directly into your <head>:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Your Article Title Here",
  "author": {
    "@type": "Person",
    "name": "Your Name"
  },
  "datePublished": "2026-04-25",
  "dateModified": "2026-04-25",
  "publisher": {
    "@type": "Organization",
    "name": "Your Site",
    "logo": {
      "@type": "ImageObject",
      "url": "https://yoursite.com/logo.png"
    }
  },
  "image": "https://yoursite.com/og-image.jpg",
  "description": "A practical developer guide to diagnosing and fixing common SEO mistakes."
}
</script>

Always validate at schema.org/docs/validator before pushing. One missing comma means Google ignores the whole block.

For apps with multiple schema types (Article, BreadcrumbList, FAQPage, Product), managing raw JSON-LD strings gets messy fast. @power-seo/schema has type-safe builders for 23 schema types with React components that inject the script tag server-side:

npm install @power-seo/schema

// app/blog/[slug]/page.jsx
import { ArticleSchema, BreadcrumbSchema } from "@power-seo/schema";

export default async function BlogPost({ params }) {
  const post = await getPost(params.slug);

  return (
    <>
      <ArticleSchema
        headline={post.title}
        description={post.excerpt}
        datePublished={post.publishedAt}
        dateModified={post.updatedAt}
        author={{ name: post.author.name }}
        image={post.coverImage}
      />
      <BreadcrumbSchema
        items={[
          { name: "Home", url: "https://yoursite.com" },
          { name: "Blog", url: "https://yoursite.com/blog" },
          { name: post.title, url: `https://yoursite.com/blog/${params.slug}` },
        ]}
      />
      {/* your page content */}
    </>
  );
}

TypeScript will catch invalid fields before they reach production. That alone has saved me from several silent failures.

Mistake #3: You're Not Auditing at the Route Level

Most SEO tools audit your homepage. Maybe a few pages you manually submit. They don't crawl every route of a dynamic app — which is exactly where the problems hide. Product pages, blog posts, user profiles. That's where your actual content lives, and that's where the gaps are.

The fix is running automated SEO audits in CI, so regressions get caught in PRs instead of weeks after deployment. @power-seo/audit is built for this — it checks meta completeness, content structure, performance rules, and more against a list of URLs:

npm install @power-seo/audit --save-dev

// scripts/seo-ci-check.js — add to your CI pipeline
const { auditPage } = require("@power-seo/audit");

const pagesToAudit = [
  "https://yoursite.com/",
  "https://yoursite.com/blog/post-1",
  "https://yoursite.com/products/widget",
  "https://yoursite.com/about",
];

(async () => {
  let failed = false;

  for (const url of pagesToAudit) {
    const result = await auditPage(url, {
      checks: ["meta", "content", "structure", "performance"],
      strict: false,
    });

    if (result.issues.length > 0) {
      console.error(`\n❌ Issues found on: ${url}`);
      result.issues.forEach((issue) =>
        console.error(`  [${issue.severity}] ${issue.message}`)
      );
      failed = true;
    } else {
      console.log(`✅ Clean: ${url}`);
    }
  }

  if (failed) process.exit(1);
})();

Add node scripts/seo-ci-check.js as a step in your GitHub Actions workflow. SEO regressions now get caught the same way lint errors do — before they ship.

Mistake #4: Ignoring Core Web Vitals Until It's Too Late

Google has used Core Web Vitals as a ranking signal since 2021. Most developers check it once with Lighthouse during development, ship the site, and only look again when traffic drops — which is usually 6–8 weeks after the damage was done.

The fix is continuous monitoring, not one-time audits. @power-seo/audit includes performance rules that check LCP, CLS, and FID thresholds as part of your regular audit runs, so you get alerted when a deploy degrades your vitals:

// scripts/seo-ci-check.js — extend your existing audit
const { auditPage } = require("@power-seo/audit");

const result = await auditPage("https://yoursite.com/", {
  checks: ["performance"],
  performanceThresholds: {
    lcp: 2500,  // ms — Google's "Good" threshold
    cls: 0.1,   // score — Google's "Good" threshold
    fid: 100,   // ms — Google's "Good" threshold
  },
});

result.issues.forEach((issue) => {
  if (issue.type === "performance") {
    console.error(`⚠️ Vitals issue: ${issue.message}`);
  }
});

Pair this with your CI pipeline from Mistake #3 and you've got a single script that audits both SEO correctness and performance on every build — no separate tools, no manual Lighthouse runs.

For a full breakdown of how I wired all of this into a single CI pipeline with GitHub Actions, I wrote it up in detail on ccbd.dev/blog/seo-mistakes-fixed-using-the-power-seo-toolkit.

What I Learned

Most SEO bugs are invisible — no error logs, no broken layouts, nothing. The only way to catch them is to actively audit every route, not wait for rankings to drop.
Treat SEO checks like lint rules — codify your requirements and run them in CI. A missing <title> caught in a PR is better than one discovered after 6 weeks of poor indexing.
Structured data is free money — it takes 20 minutes to add valid JSON-LD to your templates. Most devs skip it entirely and leave rich results on the table.
Core Web Vitals need continuous monitoring — a one-time Lighthouse run in dev doesn't reflect real-user conditions on mobile, on slow connections, or after a CDN config change.

What About You?

What SEO mistakes have quietly hurt your rankings — and how long did it take you to find them? Drop it in the comments. I'm especially curious whether anyone else has been burned by staging noindex tags making it to production (it happens more than people admit).

React SEO Guide 2026: The Exact Setup That Fixed Broken Rankings

Alamin Sarker — Thu, 23 Apr 2026 06:20:00 +0000

I spent 3 hours debugging why Google couldn't see my React app. The fix was 4 lines of code.

That's the part nobody tells you when you pick up React: the default client-side rendering setup is essentially invisible to search engines. Not broken — invisible. Your app loads perfectly in the browser, users love it, and Google's crawler bounces off an empty <div id="root"></div> like it hit a wall.

In this guide, I'll walk through the exact setup I use in 2026 to make React apps fully crawlable — covering dynamic meta tags, structured data, SSR/SSG patterns, and a quick audit workflow using a React developer tool for SEO. No fluff, no sales pitch — just the configuration that actually moves rankings.

Why React Apps Fail SEO by Default

Here's the uncomfortable truth: Googlebot does execute JavaScript, but it doesn't wait for it the same way a browser does. It crawls in two waves — a fast pass that reads raw HTML, and a slower rendering queue that might process your JS later. "Might" and "later" are not an SEO strategy.

The raw HTML of a typical Create React App looks like this when the crawler hits it:

<!DOCTYPE html>
<html lang="en">
  <head>
    <title>React App</title>
  </head>
  <body>
    <div id="root"></div>
    <script src="/static/js/main.chunk.js"></script>
  </body>
</html>

No meaningful title. No description. No content. That's what Google indexes on the first pass — an empty shell.

The fix isn't complicated, but it has multiple layers. Let's go through each one.

Layer 1: Dynamic Meta Tags With

react-helmet-async

The first thing to fix is your <head>. Every page needs unique, meaningful meta tags — not the same generic title on every route.

Install it:

npm install @power-seo/react

Wrap your app:

// index.jsx
import { HelmetProvider } from 'react-helmet-async';

root.render(
  <HelmetProvider>
    <App />
  </HelmetProvider>
);

Then use it on any page component:

// pages/BlogPost.jsx
import { Helmet } from 'react-helmet-async';

export function BlogPost({ post }) {
  return (
    <>
      <Helmet>
        <title>{post.title} | My Blog</title>
        <meta name="description" content={post.excerpt} />
        <meta property="og:title" content={post.title} />
        <meta property="og:description" content={post.excerpt} />
        <meta property="og:image" content={post.coverImage} />
        <link rel="canonical" href={`https://yoursite.com/blog/${post.slug}`} />
      </Helmet>
      <article>{/* content */}</article>
    </>
  );
}

Result: Every route now has distinct, crawlable meta tags — including Open Graph data for social sharing. The canonical tag prevents duplicate content penalties if your content appears at multiple URLs.

Layer 2: Structured Data (JSON-LD) for Rich Results

Meta tags tell Google about your page. Structured data tells Google what kind of page it is — unlocking rich results like star ratings, breadcrumbs, and FAQ dropdowns in search.

Add a reusable component:

// components/JsonLd.jsx
export function JsonLd({ data }) {
  return (
    <script
      type="application/ld+json"
      dangerouslySetInnerHTML={{ __html: JSON.stringify(data) }}
    />
  );
}

Use it with an Article schema:

// pages/BlogPost.jsx
import { JsonLd } from '../components/JsonLd';

export function BlogPost({ post }) {
  const schema = {
    "@context": "https://schema.org",
    "@type": "Article",
    "headline": post.title,
    "datePublished": post.publishedAt,
    "dateModified": post.updatedAt,
    "author": {
      "@type": "Person",
      "name": post.author.name
    },
    "image": post.coverImage,
    "description": post.excerpt
  };

  return (
    <>
      <Helmet>{/* meta tags from above */}</Helmet>
      <JsonLd data={schema} />
      <article>{/* content */}</article>
    </>
  );
}

This is one of the most underused techniques in React apps. Most devs skip it entirely, then wonder why competitor sites show rich snippets and theirs don't.

Layer 3: Static Generation for Content Pages

Dynamic meta tags are great, but they don't fix the core crawlability problem. If your content is genuinely important — blog posts, product pages, landing pages — it needs to ship as pre-rendered HTML.

With Next.js (still the most practical choice in 2026):

// app/blog/[slug]/page.jsx — Next.js 14+ App Router

export async function generateMetadata({ params }) {
  const post = await getPost(params.slug);

  return {
    title: post.title,
    description: post.excerpt,
    openGraph: {
      title: post.title,
      description: post.excerpt,
      images: [post.coverImage],
    },
    alternates: {
      canonical: `https://yoursite.com/blog/${params.slug}`,
    },
  };
}

export default async function BlogPost({ params }) {
  const post = await getPost(params.slug);
  return <article dangerouslySetInnerHTML={{ __html: post.content }} />;
}

This generates fully rendered HTML at build time (or on-demand with ISR). Google gets real content on the first pass — no waiting for JS execution.

If you're stuck with CRA or Vite and can't switch frameworks, look into react-snap for pre-rendering or vite-plugin-ssr as a lighter-weight alternative.

Layer 4: Auditing Your Setup

Once you've implemented the above, you need to verify it's actually working — not just assume it is. There are a few ways to do this:

Option 1: Google Search Console — Use "URL Inspection" → "Test Live URL" to see exactly what Googlebot sees. This is the ground truth.

Option 2: Curl the raw HTML — Check what gets served before JavaScript runs:

curl -A "Googlebot" https://yoursite.com/your-page | grep -i "<title\|description\|og:"

If that returns nothing meaningful, you have a problem.

Option 3: Use a React developer tool for SEO — I've been using @power-seo recently as a lightweight audit layer. It plugs into your React tree and surfaces missing tags, duplicate titles, and schema errors during development — kind of like ESLint but for SEO metadata. There's a good write-up on the full integration pattern over at ccbd.dev if you want to dig deeper into that workflow.

The point is: audit before deploying. Fixing SEO issues post-deployment means waiting weeks for re-crawls.

What I Learned

After shipping React apps at various scales, here's what I'd tell myself if I was starting over:

Pre-rendering beats client-side rendering for anything Google needs to index. If the page matters for search, it needs to ship as HTML — full stop.
Every page needs a unique <title> and <meta name="description">. Generic titles ("React App", "Home | Site") are a silent ranking killer.
Structured data is a multiplier, not a nice-to-have. It takes 20 minutes to add Article or Product schema and can unlock rich results that double your click-through rate.
Audit with curl before you celebrate. What the browser shows you and what Googlebot sees are often very different things.

Let's Talk:

Can React Apps Actually Rank on Google?

Short answer: yes, but not without deliberate setup. The defaults work against you.

I'm curious — what's been your biggest SEO headache in React? Have you hit the empty <div id="root"> problem in production, or found a different approach that worked? Drop it in the comments. This stuff changes fast enough that real-world experience is worth more than any guide, including this one.

Power SEO Meta vs Next SEO: Which One Is Better for Next.js App Router in 2026?

Alamin Sarker — Wed, 22 Apr 2026 06:18:22 +0000

I shipped a Next.js app last year and felt pretty good about it — clean code, fast load times, Lighthouse scores in the green. Then I noticed Google had indexed exactly one page. The homepage. Nothing else.

Turns out I'd built the entire thing with App Router and assumed metadata would "just work." It didn't. After three hours of documentation rabbit holes, I discovered the problem wasn't my content — it was how (and where) I was generating my meta tags. If you're building with the Next.js App Router in 2026, this article will save you that three-hour detour.

We'll compare two approaches: the battle-tested Next SEO library and the newer Power SEO Meta package, look at real code for both, and give you a clear answer for which to reach for depending on your project.

Why SEO Metadata Is Still Painful in App Router

The Pages Router era was simple. You dropped next-seo at the top of your component, passed it a config object, and moved on. App Router changed the game. Metadata is now handled through exported metadata objects or generateMetadata functions at the route level — a more structured but less flexible approach.

The catch? A lot of older tutorials still show the Pages Router pattern, which does not work in App Router. <NextSeo /> as a JSX component? Completely ignored in App Router. If you've been copy-pasting examples from 2022, you've likely been shipping pages with missing or broken meta tags without realizing it.

Here's the baseline App Router metadata setup that Next.js ships with:

// app/blog/[slug]/page.tsx
import type { Metadata } from 'next'

export async function generateMetadata({ params }): Promise<Metadata> {
  const post = await getPost(params.slug)

  return {
    title: post.title,
    description: post.excerpt,
    openGraph: {
      title: post.title,
      description: post.excerpt,
      images: [{ url: post.coverImage }],
    },
  }
}

This works. But it gets verbose fast — especially when you're adding Twitter cards, canonical URLs, JSON-LD structured data, and robots directives across 40 routes. That's where both Next SEO and Power SEO Meta come in.

Next SEO in App Router: The Adapter Approach

Next SEO (maintained by Garmeeh) has been the community default for years. In App Router, it ships a set of helper utilities rather than JSX components. The buildOpenGraphMetadata and similar utilities let you compose structured metadata objects without typing everything from scratch.

// app/blog/[slug]/page.tsx
import { NextSeo } from 'next-seo' // ❌ Don't do this in App Router

// Use the metadata export pattern instead
import type { Metadata } from 'next'

export async function generateMetadata({ params }): Promise<Metadata> {
  const post = await getPost(params.slug)

  return {
    title: `${post.title} | My Blog`,
    description: post.excerpt,
    alternates: { canonical: `https://mysite.com/blog/${params.slug}` },
    openGraph: {
      type: 'article',
      title: post.title,
      description: post.excerpt,
      publishedTime: post.publishedAt,
      images: [{ url: post.coverImage, width: 1200, height: 630 }],
    },
    twitter: {
      card: 'summary_large_image',
      title: post.title,
      description: post.excerpt,
      images: [post.coverImage],
    },
  }
}

This is solid and fully supported. The downside: no structured data (JSON-LD) helpers, no sensible defaults across your app, and every route file ends up with a wall of metadata boilerplate.

Power SEO Meta: A Leaner Alternative Built for App Router

Power SEO Meta takes a different philosophy — it's designed specifically for App Router from the ground up, with a composable config and JSON-LD generation built in.

npm install @power-seo/meta

// app/blog/[slug]/page.tsx
import { generateMeta } from '@power-seo/meta'

export async function generateMetadata({ params }) {
  const post = await getPost(params.slug)

  return generateMeta({
    title: post.title,
    description: post.excerpt,
    canonical: `https://mysite.com/blog/${params.slug}`,
    og: { image: post.coverImage, type: 'article' },
    jsonLd: {
      type: 'Article',
      headline: post.title,
      datePublished: post.publishedAt,
      author: { name: post.author },
    },
  })
}

The return value is a valid Next.js Metadata object with the JSON-LD script tag injected automatically. The API surface is smaller, the output is identical to what you'd write by hand, and structured data — which is increasingly important for Google's AI-powered search features in 2026 — comes along for free.

Side-by-Side: When to Use Which

Concern	Next SEO	Power SEO Meta
App Router support	Partial (utilities only)	Native
JSON-LD / Structured data	Manual	Built-in
Existing Pages Router projects	Best choice	App Router only
API surface	Large, comprehensive	Small, focused
TypeScript support	Good	Good
Bundle size	Larger	Minimal
Community / ecosystem	Mature, large	Newer, smaller

The honest answer: if you have an existing Pages Router project, stick with Next SEO. The migration cost isn't worth it and the JSX component API is genuinely ergonomic there.

For greenfield App Router projects in 2026, Power SEO Meta's leaner API and native JSON-LD support make it the more natural fit. You're not fighting against the library to generate valid metadata — it just produces what Next.js expects.

What I Learned (The Hard Way)

The Pages Router SEO patterns you know don't transfer to App Router. <NextSeo /> as a component is silently ignored — no errors, no warnings, just missing meta tags in production.
Canonical URLs are not automatic. You must set alternates.canonical explicitly, or Google may index multiple versions of the same page.
JSON-LD structured data matters more now. Google's AI Overviews in search results pull from structured data. If you're not generating it, you're leaving visibility on the table.
Default metadata at the root layout saves repetition. Both approaches support a root-level metadata export. Set your site name, default OG image, and robots directives once in app/layout.tsx and let child routes override only what they need.

If you want to explore the Power SEO Meta approach yourself, the live comparison repo is here: https://ccbd.dev/blog/power-seo-meta-vs-next-seo

Let's Talk

Here's something I'm genuinely curious about:

do you think Google handles client-side React apps fairly in 2026, or is server rendering still a hard requirement for serious SEO?

I've seen conflicting data — some SSR-only advocates, some teams running CSR apps that rank fine. Drop your experience in the comments. Bonus points if you've run an actual A/B test on this.

How to Design a Modern Website in 2026: A Developer's Practical Guide

Alamin Sarker — Tue, 21 Apr 2026 06:57:31 +0000

The Problem Nobody Talks About

You've read the articles. You've followed the tutorials. You've picked Tailwind, maybe Radix or shadcn/ui, and you're using React like everyone told you to.

And then your "modern" site still feels like it was built in 2019.

Here's the uncomfortable truth: most "modern website" advice recycles the same stack choices without addressing why certain patterns work — or what the web actually demands from a site in 2026. Core Web Vitals are now a hard ranking factor. Container queries have been baseline for two years. The CSS you're writing is still fighting the browser instead of working with it.

This article won't tell you to "just use Next.js." It'll show you the actual decisions — layout, performance, rendering, discoverability — that separate a site that looks modern from one that performs like it.

1. Layout: Stop Using Flexbox for Everything

Flexbox is one-dimensional. That's fine — until you're using it to approximate a two-dimensional grid and your alignment code looks like a tax return.

CSS Grid has been baseline since 2020. In 2026, there's no excuse not to use it for page-level layout. Here's a clean, modern approach:

/* Modern page scaffold — works without any framework */
.page-layout {
  display: grid;
  grid-template-columns:
    [full-start] minmax(1rem, 1fr)
    [content-start] min(65ch, 100%)
    [content-end] minmax(1rem, 1fr)
    [full-end];
}

.page-layout > * {
  grid-column: content;
}

.page-layout > .full-bleed {
  grid-column: full;
}

This pattern — named grid lines with a 65ch prose column — gives you a typographically sound content width and a clean escape hatch for full-bleed hero images or banners. No media queries needed for the basic structure.

Layer in container queries for components:

@container (min-width: 40rem) {
  .card-grid {
    grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
  }
}

The shift here is mental: page layout via Grid, component responsiveness via container queries. Your components stop caring about the viewport and start responding to where they actually live.

2. Performance: The Metrics That Actually Get You Ranked

Google's ranking algorithm weighs three Core Web Vitals: LCP (Largest Contentful Paint), INP (Interaction to Next Paint, which replaced FID in 2024), and CLS (Cumulative Layout Shift).

The most common LCP killer I see isn't server speed — it's hero images without proper hints:

<!-- Without this, your LCP image waits in the browser's queue -->
<link rel="preload" as="image" href="/hero.webp" fetchpriority="high" />

<!-- The image itself -->
<img
  src="/hero.webp"
  alt="Product dashboard screenshot"
  width="1200"
  height="630"
  fetchpriority="high"
  decoding="async"
/>

That fetchpriority="high" attribute alone can shave 300–600ms off LCP. Pair it with explicit width and height to eliminate layout shift (CLS).

For INP, the pattern that causes the most silent damage is heavy main-thread work during interactions. Offload it:

// Instead of blocking the main thread:
button.addEventListener('click', async () => {
  // Yield to the browser before doing heavy work
  await scheduler.yield();
  runExpensiveCalculation();
});

scheduler.yield() is now baseline in all major browsers. It's one line that makes your site feel snappier without rewriting your architecture.

3. Discoverability: The Part Developers Actually Skip

Here's a pattern I see constantly: developers spend weeks on the UI, then drop 4 meta tags in <head> and call it "SEO done."

Metadata in 2026 is a structured problem. Search engines, social platforms, and AI crawlers all consume it differently. You need at minimum:

<head>
  <title>How to Design a Modern Website | Your Site</title>
  <meta name="description" content="A practical guide to modern web design in 2026, covering CSS Grid, Core Web Vitals, and structured metadata." />

  <!-- Open Graph (Facebook, LinkedIn, Discord unfurls) -->
  <meta property="og:title" content="How to Design a Modern Website in 2026" />
  <meta property="og:description" content="Practical patterns for layout, performance, and discoverability." />
  <meta property="og:image" content="https://yoursite.com/og/modern-website-2026.png" />
  <meta property="og:type" content="article" />

  <!-- Twitter/X cards -->
  <meta name="twitter:card" content="summary_large_image" />
  <meta name="twitter:title" content="How to Design a Modern Website in 2026" />

  <!-- Canonical (critical for syndicated content) -->
  <link rel="canonical" href="https://yoursite.com/blog/how-to-design-a-modern-website" />

  <!-- JSON-LD for structured data -->
  <script type="application/ld+json">
  {
    "@context": "https://schema.org",
    "@type": "TechArticle",
    "headline": "How to Design a Modern Website in 2026",
    "author": { "@type": "Person", "name": "Your Name" },
    "datePublished": "2026-04-21"
  }
  </script>
</head>

Writing this by hand for every page is tedious and error-prone. I've been using @power-seo to automate it — it generates the full tag set from a single config object and keeps canonical URLs consistent across environments. You can see a working example of this setup at ccbd.dev.

But even if you don't use a package: write the tags. All of them. Every time.

4. Component Architecture: Composition Over Configuration

The trend that's quietly won in 2026 is headless, composable UI — Radix primitives, your own design tokens, styled with vanilla CSS or Tailwind. The "everything-in-one" component libraries are losing ground because they're harder to customize and bloat your bundle.

Here's a minimal card component that reflects current best practice:

// card.jsx — composable, accessible, no library dependency
export function Card({ children, as: Tag = 'article', className = '' }) {
  return (
    <Tag className={`card ${className}`}>
      {children}
    </Tag>
  );
}

Card.Header = function CardHeader({ children }) {
  return <header className="card__header">{children}</header>;
};

Card.Body = function CardBody({ children }) {
  return <div className="card__body">{children}</div>;
};

// Usage:
// <Card>
//   <Card.Header><h2>Title</h2></Card.Header>
//   <Card.Body><p>Content</p></Card.Body>
// </Card>

The compound component pattern keeps API surface small, slots flexible, and lets you upgrade the internals without breaking consumers.

What I Actually Learned

CSS Grid + container queries is the layout combo you should be using by default in 2026 — flexbox is for component internals, not page structure.
fetchpriority="high" on your hero image is the easiest LCP win most sites haven't shipped yet.
scheduler.yield() is one line of code that makes event handlers feel instant — stop sleeping on it.
Metadata is a system, not an afterthought. OG tags, canonical URLs, and JSON-LD are table stakes. Automate them so they're never forgotten.

If you want to explore the metadata approach in more depth, here's the writeup: https://ccbd.dev/blog/how-to-design-a-modern-website-in-2026

Let's Argue About It

Here's my genuine question for the thread: do you think React apps can rank well on Google in 2026 without SSR? I have opinions, but I've also been wrong before — the crawl behavior has changed enough times that I'm not fully confident.

Drop your experience in the comments. Have you seen client-rendered React pages ranking competitively, or is SSR/SSG still a hard requirement for discoverability? Real data points welcome.

How to Optimize React & Next.js Apps for SEO and Rank Faster

Alamin Sarker — Mon, 20 Apr 2026 06:20:29 +0000

I spent 3 hours debugging why Google couldn't see my React app. Turns out, Googlebot was rendering a blank white page — because my entire content lived inside client-side JavaScript that hadn't loaded yet. The fix was 4 lines of code. But getting to those 4 lines cost me a week of confused Google Search Console reports, zero indexed pages, and a growing suspicion that SEO for single-page applications is fundamentally broken.

It's not broken. It's just different — and most tutorials skip the hard parts.

In this article, you'll learn exactly why SPAs struggle with SEO, how to fix the core rendering problem in Next.js, how to wire up dynamic meta tags properly, and how to generate sitemaps that actually get crawled. All with copy-paste ready code.

Why Google Struggles With React SPAs (And What's Actually Happening)

Google's crawler fetches your URL, gets an HTML file, and parses it. With a traditional server-rendered page, that HTML contains your actual content. With a client-side React SPA, that HTML contains roughly this:

<!DOCTYPE html>
<html>
  <head><title>My App</title></head>
  <body>
    <div id="root"></div>
    <script src="/static/js/main.chunk.js"></script>
  </body>
</html>

No content. No headings. No text for Google to index.

Google can execute JavaScript — but it does so in a second wave, sometimes days or weeks later, using an older version of Chrome. That delay alone can tank your indexing. And even when it does render your JS, dynamic <title> and <meta> tags set via document.title are unreliable.

The solution isn't to abandon React. It's to move rendering to the server so that the HTML Googlebot receives already contains your content.

Fix 1: Use Next.js Server-Side Rendering for Content Pages

If you're on plain Create React App, migrating to Next.js is the single highest-leverage move you can make for SEO. Next.js gives you getServerSideProps and getStaticProps — both of which ensure your HTML is populated before it hits the browser or a crawler.

Here's the difference in practice:

// ❌ Client-side only — invisible to Googlebot on first pass
export default function BlogPost() {
  const [post, setPost] = useState(null);

  useEffect(() => {
    fetch(`/api/posts/${id}`).then(r => r.json()).then(setPost);
  }, []);

  return <article>{post?.content}</article>;
}

// Server-side rendered — content in HTML immediately
export async function getStaticProps({ params }) {
  const post = await fetchPostFromCMS(params.slug);

  return {
    props: { post },
    revalidate: 60, // ISR: regenerate every 60 seconds
  };
}

export default function BlogPost({ post }) {
  return <article>{post.content}</article>;
}

With getStaticProps + Incremental Static Regeneration (ISR), your pages are pre-built as static HTML, served instantly from a CDN, and refreshed in the background when content changes. For most content-heavy pages — blogs, product listings, docs — this is the right default.

Use getServerSideProps only when content must be real-time per-request (e.g., personalized dashboards). Static beats dynamic for SEO almost every time.

Fix 2: Dynamic Meta Tags That Actually Work

This is where most React SEO tutorials go wrong. Setting document.title = "My Page" in a useEffect is unreliable — crawlers often don't execute it. You need your <title> and <meta> tags in the initial HTML response.

In Next.js, use the <Head> component from next/head (or the newer generateMetadata in the App Router):

// pages/blog/[slug].jsx — Pages Router
import Head from 'next/head';

export default function BlogPost({ post }) {
  return (
    <>
      <Head>
        <title>{post.title} | My Blog</title>
        <meta name="description" content={post.excerpt} />
        <meta property="og:title" content={post.title} />
        <meta property="og:description" content={post.excerpt} />
        <meta property="og:image" content={post.coverImage} />
        <meta property="og:type" content="article" />
        <link rel="canonical" href={`https://yourdomain.com/blog/${post.slug}`} />
      </Head>
      <article>
        <h1>{post.title}</h1>
        <div dangerouslySetInnerHTML={{ __html: post.content }} />
      </article>
    </>
  );
}

// app/blog/[slug]/page.jsx — App Router (Next.js 13+)
export async function generateMetadata({ params }) {
  const post = await fetchPost(params.slug);

  return {
    title: `${post.title} | My Blog`,
    description: post.excerpt,
    openGraph: {
      title: post.title,
      description: post.excerpt,
      images: [post.coverImage],
    },
    alternates: {
      canonical: `https://yourdomain.com/blog/${post.slug}`,
    },
  };
}

The canonical tag is easy to overlook but critical — it prevents duplicate content penalties when the same post is accessible via multiple URLs (e.g., with and without trailing slashes, or via pagination params).

Fix 3: Generate a Sitemap That Scales

A sitemap tells Google which URLs exist on your site and when they were last updated. Without one, Google has to discover your pages by crawling links — which means new content can take weeks to get indexed.

Here's a dynamic sitemap generator for Next.js that pulls from your CMS:

// pages/sitemap.xml.jsx
export async function getServerSideProps({ res }) {
  const posts = await fetchAllPosts(); // your CMS fetch
  const staticRoutes = ['/', '/about', '/blog'];

  const sitemap = `<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  ${staticRoutes.map(route => `
  <url>
    <loc>https://yourdomain.com${route}</loc>
    <changefreq>monthly</changefreq>
    <priority>0.8</priority>
  </url>`).join('')}
  ${posts.map(post => `
  <url>
    <loc>https://yourdomain.com/blog/${post.slug}</loc>
    <lastmod>${new Date(post.updatedAt).toISOString()}</lastmod>
    <changefreq>weekly</changefreq>
    <priority>0.6</priority>
  </url>`).join('')}
</urlset>`;

  res.setHeader('Content-Type', 'text/xml');
  res.setHeader('Cache-Control', 's-maxage=86400, stale-while-revalidate');
  res.write(sitemap);
  res.end();

  return { props: {} };
}

export default function Sitemap() { return null; }

Submit this URL in Google Search Console under Sitemaps. The Cache-Control header ensures it's cached for 24 hours at the CDN level without going stale.

For teams managing SEO metadata at scale across many pages, a package called @power-seo provides a structured schema layer on top of Next.js metadata — it's particularly useful when you need to enforce consistent OG tags and structured data (JSON-LD) across dozens of content types without repeating the same <Head> boilerplate in every template.

What I Learned (Key Takeaways)

Client-side rendering is the enemy of fast indexing. Move content pages to getStaticProps with ISR — it's the lowest-effort, highest-impact change you can make.
Meta tags belong in the server response, not in useEffect. Use next/head or generateMetadata. If Googlebot doesn't see it in the raw HTML, it's unreliable.
Canonical tags are not optional. Duplicate URLs without canonicals are a silent SEO tax that compounds over time.
Submit your sitemap and verify in Search Console. Don't assume Google will find your pages — tell it where they are and how often they change.

If you want to dig deeper into the patterns covered here, I wrote a longer breakdown with benchmarks and more edge cases at ccbd.dev.

Your Turn

Can React apps actually rank on Google? Yes — but only if you stop treating SEO as a post-launch concern and bake it into your rendering architecture from the start.

What's the trickiest SEO issue you've hit building SPAs?
Have you found SSR to be overkill for certain use cases, or do you go static-first by default now? Drop it in the comments — I'm curious what the community's experience has been.

DEV Community: Alamin Sarker

How I Fixed My React SEO Issues Using the Right Developer Tool

Why React Apps Struggle with SEO (The Real Reason)

Step 1: Make Your <head> Tags Dynamic Per Route

Step 2: Add Structured Data Without Losing Your Mind

Step 3: Audit What Crawlers Actually See

What I Learned: Key Takeaways

Let's Talk About It

Power SEO AI vs LangChain vs Vercel AI SDK (2026 ) Guide

Why JavaScript SEO is a Different Beast

Approach 1: LangChain — Flexible but Verbose

Approach 2: Vercel AI SDK — Ergonomic, But SEO-Agnostic

Approach 3: @power-seo/ai — SEO Logic as a First-Class Concern

What I Actually Learned

Let's Talk About This

SEO Mistakes in 2026: How I Fixed Them Using the Power SEO Toolkit

Introduction: Why SEO still fails in 2026

1. Technical SEO mistakes (Crawlability issues)

Common problems:

Fix: Auto-generate sitemap

Example usage:

2. Meta tags and SERP display mistakes

Fix: Standardized meta generation

Example:

3. Poor content optimization mistakes

Problems:

Fix: Content analysis tool

Example:

4. Image SEO mistakes

Common issues:

Fix:

Example:

5. Internal linking mistakes

Fix:

Example:

6. Structured data mistakes

Common SEO mistake:

Fix:

Example:

7. Not measuring SEO performance

Fix:

Conclusion: Fix SEO mistakes systematically, not manually

From Chaos to Control: How Smart Brands Automate Consistency

What Is Automated Branding?

Why Brand Consistency Is So Hard Today

How Automated Branding Solves the Problem

1. Living Brand Systems Instead of Static Guidelines

2. AI-Powered Content Creation

3. Automated Brand Compliance Checks

4. Connected Marketing Workflows

The Business Impact of Automated Branding

Tools That Enable Automated Branding

Human + AI: The Right Balance

Conclusion: From Chaos to Control

Power SEO Content Analysis Review for Developers

The Problem: What Crawlers See vs. What You See

Automating Keyword Density and Readability Audits

Where a Dedicated Tool Fits: @power-seo/content-analysis vs seo-analyzer

Plugging Audits Into Your CI Pipeline

What I Learned

Let's Talk About It

How to Rank Next.js Apps in Google: Full SEO Guide for 2026

Why Next.js SEO Is a Different Beast

Structured Data: The Part Most Developers Skip

Dynamic Sitemaps and Robots.txt (The Right Way)

Automating SEO Audits Before You Deploy

What I Learned

Let's Talk

Why JavaScript SEO Fails and How to Fix It: A Deep Dive into Modern SEO Analysis

Why Googlebot Isn't Your User

Detecting the Real Problem Programmatically

The Three Most Common Fixes (and When to Use Each)

Validating Fixes at Scale with Structured SEO Audits

What I Learned (The Hard Way)

Let's Talk About It

Fixing Common SEO Mistakes with the Power SEO Toolkit (Developer Guide

Mistake #1: Your <head> Is a Disaster and You Don't Know It

Mistake #2: Broken or Missing Structured Data

Mistake #3: You're Not Auditing at the Route Level

Mistake #4: Ignoring Core Web Vitals Until It's Too Late

Step 1: Make Your `<head>` Tags Dynamic Per Route

Where a Dedicated Tool Fits: `@power-seo/content-analysis` vs `seo-analyzer`

Mistake #1: Your `<head>` Is a Disaster and You Don't Know It