Programmatic SEO: Scale Without the Spam

Programmatic SEO (pSEO) is the practice of generating large numbers of similar pages from a single template fed by a structured dataset. Done well, it’s how Zillow ranks for every “homes for sale in [city]” query, how Wise ranks for every currency pair, and how G2 ranks for every “[category] software” comparison. Done poorly, it’s a one-way ticket to a Helpful Content classifier penalty.

Programmatic SEO sandbox

Edit the variables and template — see the URL graph generate live.

ResetGenerate architecture

{Locations}3 valuesInsert into template

CharlotteConcordRaleigh

Add

{Services}3 valuesInsert into template

Pet CremationAquamationVendor Services

Add

Add variable

URL template

Available tokens: {Locations}{Services}

9 pages generated

Below the thin-content tripwire. Each combination must still earn its page with non-trivial content.

Generated architecture

9 URLs

/locations3

/charlotte3

/pet-cremation

/aquamation

/vendor-services

/concord3

/pet-cremation

/aquamation

/vendor-services

/raleigh3

/pet-cremation

/aquamation

/vendor-services

Each generated URL needs unique value beyond template substitution to avoid being scored as thin.

This module is the Expert-level playbook: when pSEO works, when it doesn’t, and the technical patterns that separate compounding traffic from sitewide demotion.

The mental model: data × template × demand

Every successful pSEO project sits at the intersection of three forces:

1. Search demand at scale. Long-tail queries with consistent structure — [noun] in [location], [product] vs [product], convert [unit] to [unit].
2. A structured data source. A database, an API, a public dataset, or a scrape — something with rows that map cleanly to URLs.
3. A template that adds genuine value. Not just “Insert City Name Here,” but a page where the combination of variables produces something a human would actually choose to visit.

When all three are present, you can publish 50,000 pages in a weekend that each rank because they answer a real query better than the alternative. When any one is missing, you’re building a doorway page farm.

When to use pSEO (and when not to)

Use programmatic SEO when all of the following are true:

• The query pattern is genuinely repetitive ([A] [B] or [A] in [B]).
• You can answer each variant with distinct, useful information — not just rearranged words.
• You have authoritative data the user can’t easily get elsewhere, or you can synthesize multiple sources into one view.
• Each generated page can stand on its own as a quality result.

Avoid programmatic SEO when:

• Your only differentiator is “we made a page for this.”
• The data you’d template is one Wikipedia query away.
• You’d be generating combinations the underlying data doesn’t actually support (e.g., “best dentists in [town of 200 people]” — there are no dentists there).

Identifying entity sets

The first deliverable of any pSEO project is an entity inventory: the lists you’ll cross-multiply. Examples:

Project type	Entity A	Entity B	Result
Real estate	Cities	Property type	”Condos for sale in Austin”
FX / fintech	Currency	Currency	”USD to JPY exchange rate”
SaaS comparison	Product	Product	”Notion vs Obsidian”
Travel	Origin city	Destination city	”Flights from Boston to Lisbon”
Tools	Unit	Unit	”Convert miles to kilometers”

The viable combinations are usually A × B — but blindly multiplying gives you garbage. Filter aggressively to combinations that have observed search demand or business value.

URL structure that scales

URLs are your most permanent decision. Get them wrong and you’re paying off the debt for years.

✅ Stable, descriptive, scoped
/cities/austin/condos-for-sale
/currencies/usd-to-jpy
/compare/notion-vs-obsidian
/flights/bos-to-lis

❌ Fragile or nondescript
/listings?city=austin&type=condos     // params get crawled poorly
/p/12892                              // no semantic meaning
/austin-condos-for-sale-cheap-best    // keyword stuffed
/AUSTIN/Condos_For_Sale               // case + underscores hurt

Rules of thumb:

• Lowercase everything. Hyphens, never underscores.
• Use stable, semantic identifiers (/usd-to-jpy/) over opaque ones (/fx/01H8X...).
• Group by the most important entity first — the one users would naturally browse to.
• Trailing slash or no trailing slash: pick one, redirect the other, never both. This is the single most common pSEO crawl-budget leak.

A minimal Astro route for pSEO

Astro’s getStaticPaths is purpose-built for templated routes. Here’s the canonical pattern:

// src/pages/compare/[slug].astro
import { getCollection } from 'astro:content';
import comparisons from '../../data/comparisons.json';

export async function getStaticPaths() {
  return comparisons
    // Filter for combinations that have demand AND data
    .filter((c) => c.searchVolume >= 50 && c.hasBothProducts)
    .map((c) => ({
      params: { slug: `${c.a.slug}-vs-${c.b.slug}` },
      props: { comparison: c },
    }));
}

const { comparison } = Astro.props;

Notice the filter. Always filter before you generate. Building a page for every combination then noindexing the bad ones is the wrong order — you’ve already spent the crawl budget.

Adding genuine value at the template layer

This is where most pSEO operations die. The template needs to do at least one of:

1. Aggregate data the user would otherwise have to compile themselves (price history, multi-source ratings, regulatory data).
2. Compute something (mortgage payment for the city’s median price at today’s rates, FX conversion at the live mid-market rate).
3. Surface user-generated content at scale (reviews, Q&A, real listings).
4. Provide a unique editorial layer (a reviewer’s notes, an expert annotation, a regional caveat).

Pure substitution — <h1>Best {service} in {city}</h1> followed by boilerplate — is a Helpful Content land mine. You will get classifier-detected, and the demotion is sitewide, not page-by-page.

The thin content tripwires

The specific failure modes Google’s classifier looks for:

• Near-duplicate body content across a generated set (boilerplate ratio > ~70%).
• Empty data states — pages where the dataset has no real values, so the template falls back to “There are no listings in [city] right now.”
• Combinatorial garbage — pages for combinations no human would type (Convert millivolts to leagues).
• No crawl path in — orphaned pages reachable only via the sitemap, indicating no editorial endorsement.
• Stale data with no dateModified updates as the source moves on.

Quality control: the 1% audit

Before launch, sample at least 1% of generated URLs at random and review them as a user. Three failure modes to watch for:

1. The page renders, but the answer it gives is wrong or empty.
2. The page renders correctly, but reads like spam.
3. The page is fine, but the query it targets has no real intent (you’re solving a problem no one has).

Kill any page in any of these buckets — kill the category, not just the URL.

Internal linking at scale

Pages that are only reachable from the sitemap don’t rank. The internal link graph is what tells Google a page belongs in the index.

Three patterns that work:

1. Hub pages that list the top 50–200 children with editorial context. /cities/ lists every city with a paragraph each, not a 12,000-row dump.
2. Lateral links between siblings — “Also compared: A vs C, A vs D” — capped at the most semantically related neighbors.
3. Contextual links from your editorial content — a hand-written guide that links into 30 generated pages signals far stronger than 30,000 pages linking to each other.

// Cap lateral links by similarity, not by alphabet
const related = allComparisons
  .filter((c) => c.category === current.category && c.slug !== current.slug)
  .sort((a, b) => b.similarityScore(current) - a.similarityScore(current))
  .slice(0, 8);

Indexing strategy

Don’t submit 50,000 URLs to Google Search Console on day one. The pattern that gets the most pages indexed:

1. Launch the hub pages first with full editorial content (10–50 URLs).
2. Release children in waves of 1,000–5,000 per week, prioritized by demand.
3. Use IndexNow (indexnow.org) for Bing/Yandex; Google still relies on crawl + sitemap.
4. Watch GSC’s Coverage report. If “Discovered – currently not indexed” balloons, stop expanding and improve quality.

Real-world examples to study

Site	Pattern	Why it works
Zillow	One page per address	Authoritative price history, photos, neighborhood data
TripAdvisor	One per place + activity	UGC reviews that don’t exist elsewhere
Wise	One per currency pair	Live rates + transparent fee math
NerdWallet	One per credit card / loan / city	Editorial scoring layered on data
G2	One per software category & comparison	Real user reviews, scoped by buyer role
Yelp	One per business + city	UGC + location signals

What they all share: the data behind the page is the moat. The template is just the delivery mechanism.

Tools and stacks

Stack	Best for
Astro / Next.js + JSON / API	Engineers who want full control + perfect Lighthouse scores
Webflow + Airtable / Memberstack	Marketers who can sustain ~5,000 pages without dev help
WordPress + WP All Import + ACF	Existing WordPress sites with clean data sources
Custom Python + Jinja + S3	Data-heavy projects with millions of pages

The stack is the least important decision. The data quality and template intelligence are 95% of the outcome.

Programmatic SEO with AI (used responsibly)

LLMs change the cost structure of pSEO, but they don’t change the rules. Specifically:

• Use AI for the editorial layer, not for the data. AI can write the regional caveat or the comparison summary; it cannot invent the price history.
• Bound AI output with structured data. Pass the LLM your verified facts and constrain it to those facts only — temperature: 0.2, system prompt that forbids embellishment.
• Always have a human in the loop on the template, even if individual page generation is automated. One bad template equals every page bad.
• Disclose synthesis honestly. If the analysis is AI-assisted, say so on the page. Trust signals matter for E-E-A-T more than ever.

Governance: the piece every team skips

Programmatic SEO is the only SEO discipline where you can demote your entire site with one bad merge. Treat it like infrastructure:

• A review checklist before any new pSEO directory ships.
• A kill switch — robots.txt rules, a noindex toggle in your CMS, and a redirect plan — before you need them.
• Quarterly pruning. Pages that didn’t earn impressions in 90 days either get rewritten or removed. Compounding stale templates is what trips the Helpful Content classifier.
• Monitoring that alerts when a generated directory’s average quality score drops, not just when a single page breaks.

What to do next

1. List one query pattern in your industry where users repeatedly type [A] [B].
2. Source a dataset where you can answer ≥ 1,000 of those combinations with non-trivial content.
3. Prototype a template against 20 hand-picked combinations — review them as a user.
4. If 19 of 20 feel useful, scale to 200, then 2,000.
5. If 5 of 20 feel useful, the project isn’t pSEO. It’s a content strategy problem.

Programmatic SEO is leverage. Leverage on a quality foundation compounds; leverage on a thin one is a controlled demolition of your domain authority.