Programmatic SEO: When It Works and When Google Punishes It

Wise has around 8.5 million automatically generated pages for its currency converter and, according to Semrush estimates reported by Backlinko, the site gets more than 100 million visits a month. Datanyze did something very similar, with generated pages for every company and every person in its database, and in Ahrefs' September 2024 analysis it had lost 95% of its estimated organic traffic.

Same technique, opposite outcomes. It's called programmatic SEO, and it usually gets sold with a promise: ten thousand pages over a weekend, traffic without writing a line. The gap between Wise and Datanyze explains why that promise is half true and half dangerous.

What Programmatic SEO Is (and Why It's Not a Shortcut)

Programmatic SEO means generating lots of pages from a structured dataset and a template. Instead of writing each page by hand, you start from a search that has a fixed part (the head term) and a variable part (the modifier), and you create one page for every combination that makes sense.

A few examples of the pattern:

Put like that, it sounds like a writing technique. It's really a data project. You write the template once: what decides whether a page is worth anything is what you put inside it, and that comes from the database.

Before asking how many pages you can generate, ask how many combinations you have data for that nobody else has.

The Examples That Work: Wise and Zapier

Wise is the textbook case. Each conversion page shows the current exchange rate and Wise's own service data for that currency pair. That's data Wise has because it's its business, and it's genuinely useful to someone searching "1000 euros to dollars." Backlinko counts 170 sitemaps of 50,000 URLs each for the converters alone.

Zapier does the same with integrations: more than 590,000 pages, and the /apps/ section alone brings in over 610,000 organic visits a month (also a Semrush estimate). Each page describes what you can automate between two specific apps, with real triggers and actions pulled from the product.

There's also an Italian case with numbers attached. In its programmatic SEO guide, the agency NetStrategy describes its work on TraghettiPer, a network of about ten vertical ferry-booking portals: more than 210 pages segmented by destination and, over one year, organic traffic up 132% and average organic revenue up 111%. The agency credits the result to the quality of the segmentation, not to multiplying identical pages.

What these have in common is that the generated page answers better than any hand-written page could. It's the only place where you find that combination of data, and Google has no reason to prefer a summary written somewhere else.

When Google Punishes Programmatic SEO: Datanyze and Causal

Datanyze is the opposite case. According to Ahrefs' analysis of the sites that lost the most traffic, its estimated organic traffic went from 486,626 to 22,077 monthly visits, down 95.46%. Ranking pages dropped from 1,168,889 to 377,142, and more than 80% of the loss sits in /companies and /people: the generated profiles for each company and each person.

Causal, in the same analysis, fared even worse: from 307,158 to 1,485 estimated visits, down 99.52%. There, the pages were 1,800 AI-generated articles built from a competitor's sitemap, an operation publicly described on X as an "SEO heist."

What Google Actually Says

In March 2024 Google updated its spam policies and introduced scaled content abuse: it's "when many pages are generated for the primary purpose of manipulating Search rankings and not helping users," and it applies "no matter how it's created," by automation or by people. The rule builds on the earlier policy about automatically generated content.

The spam policies page gives very concrete examples: using generative AI to create many pages "without adding value for users," scraping, automated transformations like synonymizing and translating, stitching together other people's content.

In the same update, the old helpful content system became part of the core ranking systems. In practice, there's no longer a separate filter you can dodge: page quality weighs on everything else.

In May, Google got even more explicit in its guide to optimizing for AI search: creating a page for every possible variation of how people might search violates the scaled content abuse policy, because "a high quantity of pages doesn't make a website higher quality." It's the same shift I wrote about in January in my piece on Search Everywhere Optimization: what counts is being the best source, not being everywhere.

John Mueller put it less diplomatically back in 2023: programmatic SEO is often "a fancy banner for spam."

On September 7 he came back to it on Bluesky, replying about a site built by combining domain names, technologies and attributes. "Programmatic SEO like this often leads to a site that's either spam, borderline spam, or low quality," he wrote, and "our systems have possibly lost faith in your site providing good value to users based on the old pages." Fixing it "tends to take time & significant effort to show the value."

That's the part people underestimate most: weak pages don't stay isolated, they weigh on how the whole site is judged. And Google isn't slowing down: in 2026 it has already shipped four spam updates, in March, June, August and September, and the September one, which started on the 24th, is still rolling out as I write.

AI Made Things Worse

Before language models, the limit of programmatic SEO was that filling ten thousand pages took ten thousand real data points. Now filler text costs nothing, and the temptation is to generate pages that look different but say nothing new.

Lily Ray analyzed more than 220 sites that were clients of AI content platforms: 54% lost at least 30% of their traffic from peak, and 22% lost at least 75%. One of the recurring patterns is exactly multiplying pages by location and language. She's careful to say it's correlation, not proof of cause, but the signal is clear.

"Service + City" Pages Are Usually Doorways

There's a form of programmatic SEO that's everywhere among small businesses and freelancers: one page for every town in the area, with the same text and the town name swapped. "Plumber in Leeds," "Plumber in Bradford," "Plumber in Wakefield," and on it goes for dozens of pages.

Google has a specific name for this, and it's older than scaled content abuse: doorway abuse. Among the examples in its spam policies are "having multiple domain names or pages targeted at specific regions or cities that funnel users to one page" and "creating substantially similar pages that are closer to search results than a clearly defined, browseable hierarchy."

The reason is simple: it's the same plumber, the same phone number, the same service. The Bradford page adds nothing to the Leeds one. If one day you really have something different to say for each area (measured response times, jobs done there, reviews from customers in that town), the page has a reason to exist. Until then, it doesn't.

A simple test: if I remove the city name from the page, can I still tell which city it's about? If not, that page shouldn't exist.

How I'd Design It in Laravel

Most guides you'll find online talk about no-code tools: Google Sheets, Webflow, Airtable. For developers, the interesting part is something else: how to build a system that decides on its own which pages deserve to exist.

Let me take a made-up but realistic example: a job board that wants a page for every profession in every city. The pattern is "jobs + profession + city." The possible combinations number in the hundreds of thousands; the ones that make sense, far fewer.

A Page Exists Only If There's Data

The first rule lives in the controller: if there's nothing for that combination, the page doesn't exist. No empty template saying "no listings in Bradford," which is exactly the kind of thin content Google penalizes.

// routes/web.php
Route::get('/jobs/{profession:slug}/{city:slug}', JobListingPageController::class)
    ->name('listings.city');

class JobListingPageController extends Controller
{
    // Below this threshold the page exists for visitors, but we don't ask Google to index it
    private const int MIN_LISTINGS_TO_INDEX = 5;

    public function __invoke(Profession $profession, City $city): View
    {
        $listings = $profession->listings()
            ->whereBelongsTo($city)
            ->active() // scope for listings that are still open
            ->latest()
            ->get();

        // No data, no page
        abort_if($listings->isEmpty(), 404);

        return view('listings.city', [
            'profession' => $profession,
            'city' => $city,
            'listings' => $listings,
            'indexable' => $listings->count() >= self::MIN_LISTINGS_TO_INDEX,
        ]);
    }
}

Below the Threshold: noindex, With Judgment

Between "no data" and "enough data" there's a gray zone. A page with two listings is useful to someone coming from an internal link, but it's not a page you want at the top of Google.

{{-- resources/views/listings/city.blade.php --}}
@unless ($indexable)
    @push('meta')
        <meta name="robots" content="noindex, follow">
    @endpush
@endunless

One caveat: noindex doesn't save Googlebot any work. Google's crawl budget guide points out that noindexed pages still get fetched. If your weak combinations number in the tens of thousands, it's better not to link them at all, or not to generate them in the first place. NetStrategy takes the same line in its guide: "not every combination deserves an indexable URL from day one."

A Sitemap Only for Pages That Earn It

The sitemap is how you tell Google which pages you consider important. Putting every possible combination in it is the fastest way to show you haven't made any selection. With spatie/laravel-sitemap and a sitemap index, each file capped at 50,000 URLs per Google's limit:

use Spatie\Sitemap\Sitemap;
use Spatie\Sitemap\SitemapIndex;
use Spatie\Sitemap\Tags\Url;

$index = SitemapIndex::create();

// listing_pages: summary table with one row per combination and its listing count
ListingPage::query()
    ->where('listings_count', '>=', 5)
    ->orderBy('id')
    ->chunk(50_000, function ($pages, int $chunk) use ($index) {
        $sitemap = Sitemap::create();

        foreach ($pages as $page) {
            $sitemap->add(Url::create($page->url)->setLastModificationDate($page->updated_at));
        }

        $path = "sitemaps/listings-{$chunk}.xml";
        $sitemap->writeToFile(public_path($path));
        $index->add("/{$path}");
    });

$index->writeToFile(public_path('sitemap.xml'));

The Template: Blocks That Appear Only When the Data Is There

The last trap is the one-size-fits-all template. If every page has the same six paragraphs with three words swapped, the difference between one page and the next is close to zero. A better template is made of blocks that show up only when there's data for them: average salary if enough listings include one, hiring companies if there's more than one, a comparison with nearby cities if you have the numbers.

That way two pages built on the same pattern end up genuinely different, because the data filling them is different.

Before You Generate the First Page

If I were starting a programmatic SEO project tomorrow, this is the list I'd check:

1. First-party data. For each combination, do I have something that isn't already in Google's top ten results?
2. Real intent. Does anyone actually search for that combination? Checking a sample of queries in Search Console or a keyword research tool saves you from generating pages for searches that don't exist.
3. Threshold. What's the minimum amount of data below which the page shouldn't be indexed, or shouldn't be created?
4. Hierarchy. Can the pages be reached from hub pages (profession, region, city), or do they only exist in the sitemap?
5. Staged rollout. Start with a few hundred pages, then check in Search Console how many get indexed and how they rank. Backlinko puts it bluntly: don't push 100,000 URLs live overnight.
6. Monitoring. Indexing report, crawl stats and cannibalization between pages of the same pattern, checked weekly in the early stages.

Programmatic SEO FAQ

Is programmatic SEO dead?

No. Wise and Zapier show it still works, as long as every page carries useful data of its own. What's dead is the "same text with one word swapped" version, and with generative AI Google is hunting it down even more actively.

Does Google penalize programmatic SEO?

Google doesn't penalize the technique, it penalizes the result. Its spam policies talk about scaled content abuse when pages exist to manipulate rankings rather than help users, however they were created.

Can I use AI to write the page copy?

Google has said for a while that appropriate use of AI or automation is not against its guidelines. The trouble starts when AI is used to fill pages that have nothing of their own. Using it to describe real data is fine; using it to make up the content isn't.

How many pages do I need for programmatic SEO?

There's no minimum. What matters is the ratio of pages to data: 300 full pages beat 30,000 empty ones. Google says so explicitly: a high quantity of pages doesn't make a website higher quality.

Are "service + city" pages always against the rules?

No, they're against the rules when they're doorways: near-identical pages that exist only to catch local searches and send everyone to the same place. If you have real, different content for each area, they're legitimate pages.

Programmatic SEO Works Where the Data Is the Product

Looking at the examples that hold up and the ones that collapse, the line seems clear to me. Programmatic SEO works when the site already has data worth something, and the pages are just the way to make it findable. It fails when the pages are the product and the data is an excuse to generate them.

With language models, the cost of generating a page has dropped close to zero, and Google has responded by shifting its attention from "how" to "why": it doesn't care whether a person or a template wrote the page, it cares whether the page had a reason to exist. For developers that's good news, because the hard part to copy isn't the template. It's the data, and the discipline not to publish the pages that don't have any.