PageForge 1.3: check every run before it writes, update generated pages, spintax and resumable batches. See what changed
Account Get it free

Programmatic SEO site architecture: URLs, hubs and crawl depth

How to structure large sets of generated pages: URL patterns, hub-and-spoke trees, parent pages, breadcrumbs, hub pagination, sitemaps and crawl depth.

Programmatic SEO site architecture is the plan that decides where hundreds or thousands of generated pages live, how they link to each other, and how a visitor or a crawler gets from your home page to any one of them. Get it right and every page has a parent, a path and a single job. Get it wrong and you publish a thousand pages that only the XML sitemap knows about.

Key takeaways

  • Fix one URL pattern per page family before you generate anything. Changing it later creates new URLs, not updated ones.
  • Build top-down: home page, family hub, group hub, then the generated pages. Hubs must exist before their children.
  • Keep every page within about four clicks of the home page, and calculate it rather than guessing.
  • Breadcrumbs come from your theme or SEO plugin, and they follow the parent hierarchy you give your pages.
  • Split a long hub by a second dimension before you paginate it. If you must paginate, give every page its own URL and link the pages with ordinary links.
  • Watch indexing per page family, using separate sitemaps or URL folder filters in Search Console.
  • One search intent, one URL. Keep a keyword-to-URL map and check it before every run.

What programmatic SEO site architecture has to do

A generated page set has the same needs as any website, multiplied. The architecture has four jobs:

  1. Discovery. Every page can be reached through normal links from pages people already visit.
  2. Context. A page’s position, its parent, its hub and its neighbors, tells visitors and search engines what group it belongs to.
  3. One job per URL. No two pages compete to answer the same search.
  4. Maintainability. The patterns still work when the data doubles, a city is renamed or a service is dropped.

Size changes which of these bites first. Google’s SEO starter guide notes that once a site has more than a few thousand URLs, how you organize content may affect how Google crawls and indexes it, and that grouping topically similar pages in directories lets Google learn how often each directory changes.

Page setWhat needs the most attention
Under 100 pagesOne hub page and clean slugs. Flat URLs are fine.
100 to 1,000 pagesTwo levels of hubs, related links between neighbors, one sitemap you actually check
1,000 to 10,000 pagesThree levels of hubs, crawl depth checks, indexing tracked per page family
Over 10,000 pagesEverything above. If the pages change daily, Google’s crawl budget guidance becomes relevant

Planning the structure before the data also tells you whether the page set makes sense at all. If you cannot say what the parent of a page is, the page probably does not have a clear job. The programmatic SEO guide covers the method as a whole. This post is about where the pages live.

URL patterns for programmatic pages

The common patterns

PatternExampleGood forWatch out for
Flat, at the root/ac-repair-austin-tx/Small sets and simple sitesSlugs must be unique site-wide, and nothing groups the pages
Nested under hubs/areas/texas/austin/ac-repair/Large local sets and anything with a clear hierarchyLonger URLs, and every parent must exist first
A content-type prefix/locations/the-magnolias/Keeping a campaign apart from hand-built pagesChanging the prefix changes every URL in the set
Query parameters/find?city=austin&service=acFilters and internal searchEndless near-duplicate URLs, and poor landing pages

Query parameters are not a landing page strategy. Use them for filtering on a hub if you need to, and keep the pages you want in search results on clean paths.

Slug rules that save you later

Google’s URL structure guidelines recommend readable words rather than IDs, hyphens rather than underscores, and one consistent case, because Google treats URL paths as case-sensitive. For generated slugs, add these:

  • Include the disambiguator when names repeat. Portland, Oregon and Portland, Maine need the state in the slug: ac-repair-portland-or.
  • Use the words people search. ac-repair over air-conditioning-maintenance-services, if that is the phrase your customers use.
  • Leave out anything that will change. Years, prices and offers belong in the content, not the URL.
  • Check the cleaned-up slug. WordPress lowercases, turns spaces and periods into hyphens, strips most punctuation and removes accents, so “St. Louis” becomes st-louis and “SΓ£o Paulo” becomes sao-paulo. Two rows can clean up to the same slug. See title and URL patterns.

Choose the dimension order

Most programmatic sets combine two dimensions, such as service and place, or product and use case. The order in the URL implies the hub structure.

OrderExampleThe hubs it impliesSuits
Place first/areas/texas/austin/ac-repair/City hubs listing servicesLocal businesses, where the customer picks the nearest branch first
Service first/services/ac-repair/austin-tx/Service hubs listing citiesServices that differ a lot, or providers where the service is the main choice
Combined slug/ac-repair-austin-tx/None by defaultSmall sets, or setups where every page shares one parent

Pick the order that matches how a visitor narrows the choice, and build one tree. Building both trees, place-first and service-first, gives you two URLs for every combination, which is a cannibalization problem waiting to happen. Link across instead: a service hub can link to every city’s service page without owning those pages in its URL.

Keep URLs stable

URLs are the identity of generated pages. When you update a set from new data, most tools find existing pages by URL. Change the slug pattern or a value used in it, and the next run sees new URLs, creates new pages and leaves the old ones in place. Redirect the old addresses with your SEO or redirect plugin, and update every link that pointed to them. The duplicates guide walks through how URLs are compared and why a renamed city produces a new page.

Hub-and-spoke structures

A hub is a page that links to a group of related pages and gives them context. A spoke is one of those pages. Large sets are usually hubs of hubs.

A local service business

/                                   home
└── /areas/                         hub: every state
    β”œβ”€β”€ /areas/texas/               state hub: every city in Texas
    β”‚   β”œβ”€β”€ /areas/texas/austin/                city hub: services in Austin
    β”‚   β”‚   β”œβ”€β”€ /areas/texas/austin/ac-repair/
    β”‚   β”‚   β”œβ”€β”€ /areas/texas/austin/furnace-repair/
    β”‚   β”‚   └── /areas/texas/austin/duct-cleaning/
    β”‚   └── /areas/texas/round-rock/
    └── /areas/oklahoma/
/services/                          hub: every service
└── /services/ac-repair/            service hub: links to every city's AC repair page

A SaaS integrations library

/integrations/                      hub: every integration, grouped by category
β”œβ”€β”€ /integrations/crm/              category hub
β”‚   β”œβ”€β”€ /integrations/crm/salesforce/
β”‚   └── /integrations/crm/pipedrive/
└── /integrations/accounting/
    β”œβ”€β”€ /integrations/accounting/xero/
    └── /integrations/accounting/quickbooks/

A directory

/directory/                         hub: categories and top cities
β”œβ”€β”€ /directory/physiotherapists/                    category hub
β”‚   β”œβ”€β”€ /directory/physiotherapists/leeds/          category and city
β”‚   β”‚   └── /directory/physiotherapists/leeds/example-clinic/   profile
β”‚   └── /directory/physiotherapists/york/
└── /directory/osteopaths/

The same shape repeats: a family hub, group hubs, then the pages. Each level narrows the choice by one dimension.

What makes a hub worth visiting

A hub that is only a list of links is a weak page and a weak signal. A good hub:

  • Opens with a few sentences that say what the group covers and who it is for.
  • Groups the links so a visitor can scan them, by state, by category or by first letter.
  • Adds one useful fact per link, such as a starting price, an arrival time or the number of providers.
  • Links up and across, to its parent hub and to sibling hubs.
  • Is linked from the navigation or the footer, or from a hub that is.

There is no fixed number of links that makes a hub too long. A practical test: if a visitor cannot find their city in a few seconds, split the hub by another dimension.

Parent pages and hierarchy in WordPress

WordPress gives you the hierarchy for free if you use the right content type. Pages can have a parent page, and the parent’s slug becomes part of the URL, so a page austin under texas under areas lives at /areas/texas/austin/. Posts do not have parents: their URLs follow your post permalink structure. Custom post types depend on how they are registered, and often use a fixed prefix.

Nested Page URLs need pretty permalinks. Under Settings > Permalinks, any structure other than Plain works. Plain permalinks use ?p=123 style addresses and ignore the hierarchy.

Three rules keep a hierarchy healthy:

  • Parents first. A page cannot sit under a parent that does not exist yet, so publish hubs before their children.
  • One parent per page. That parent is the page’s primary hub, and the breadcrumb trail follows it.
  • Moving a parent moves its children’s URLs. Changing a hub’s slug changes every URL below it, so treat hub slugs as permanent.

How PageForge places generated pages

In PageForge, set a template’s Target Post Type to Page and choose a Parent Page. The free plugin puts every page from one template under that parent, so several hubs mean one template per hub. Pro, from the Starter plan, reads each row’s parent from a Parent Path or Parent ID column. Parents must exist before the run, existing pages are not moved when the parent changes, and Check and preview shows the first page’s full path before anything is written. See the parent pages guide and pages, posts and URLs.

Breadcrumbs from the theme or SEO plugin

Breadcrumbs show a page’s place in the hierarchy and let a visitor move up one level at a time: Home β€Ί Areas β€Ί Texas β€Ί Austin β€Ί AC Repair. On a programmatic site they do two useful things. They give every generated page links back up to its hubs, and they make the structure visible to people who landed deep in it from search.

Breadcrumbs usually come from your SEO plugin, as Yoast SEO and Rank Math both offer them, or from your theme. For Pages, they are built from the parent chain, which is one more reason to nest generated Pages under real hubs. With flat URLs and no parents, the trail collapses to Home β€Ί AC Repair in Austin, TX, which tells nobody anything.

Google’s breadcrumb structured data documentation describes the markup: a BreadcrumbList with at least two items, each with a position, a name and, except for the last, an item URL. It also recommends a trail that reflects a typical user path rather than mirroring the URL, and allows more than one trail for a page that can be reached in several ways. A minimal example for the Austin page:

{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    { "@type": "ListItem", "position": 1, "name": "Areas", "item": "https://example.com/areas/" },
    { "@type": "ListItem", "position": 2, "name": "Texas", "item": "https://example.com/areas/texas/" },
    { "@type": "ListItem", "position": 3, "name": "Austin", "item": "https://example.com/areas/texas/austin/" },
    { "@type": "ListItem", "position": 4, "name": "AC Repair" }
  ]
}

PageForge does not generate breadcrumbs or breadcrumb schema. It gives your SEO plugin or theme the parent hierarchy to build them from. Turn breadcrumbs on, open one generated page and check that the trail matches the path.

Paginating large hubs

A hub with 40 links is easy to use. A hub with 900 is not, and a single page that long is heavy to load and hard to scan.

Split before you paginate

The first fix is structural. Instead of one “All cities” hub with 900 links, add a level: an “Areas” hub with 4 state hubs, each with its own list of cities. Splitting by a dimension visitors understand keeps every list short and adds a hub that has a real reason to exist.

When pagination is the right answer

Some lists have no natural second dimension, such as 600 integrations in one category or 2,000 profiles in one city. Then paginate, and follow Google’s pagination guidance:

  • Give every page its own URL, such as ?page=2 or /page/2/. Do not use URL fragments (#page2), which Google ignores.
  • Link the pages in sequence with ordinary <a href> links. A link from each page back to the first page is also useful.
  • Let each page be its own canonical. Do not point every page’s canonical at page 1, or the items on later pages lose their only link.
  • Do not rely on rel="next" and rel="prev". Google no longer uses them, though other search engines may.
  • Keep filtered and sorted variations out of the index with noindex or a robots.txt rule.

The depth cost of pagination

Pagination pushes items deeper. If a hub shows 50 links per page and an item sits on page 12, a visitor following “next” needs 11 extra clicks to reach it. Order matters: put the items that matter most on the first page, and give later items other paths in, such as links from sibling pages or a second hub that groups them differently.

Hub lists in PageForge

The PageForge Sitemap block, or the [pageforge_sitemap] shortcode, lists generated pages on a hub. In the free plugin it shows published generated pages of the chosen content types, grouped by City, State or Service, up to a limit of 5,000. It has no pagination setting and cannot be narrowed to one state, so split large sets into several hubs. Pro adds include and exclude. See hub pages with the sitemap block.

XML sitemaps for large page sets

An XML sitemap lists the URLs you want search engines to know about. For a programmatic set it is a backup discovery route and, more usefully, a monitoring tool.

The limits and the rules

Google’s sitemap documentation sets the ground rules:

  • A sitemap can hold up to 50,000 URLs or 50MB uncompressed. Larger sets are split into several sitemaps listed in a sitemap index.
  • List canonical URLs only, the versions you want in search results.
  • lastmod is used when it is consistently accurate, and should reflect real changes to the main content, structured data or links. A changed copyright year is not one.
  • priority and changefreq are ignored.
  • Submit through Search Console, or add a Sitemap: line to robots.txt.
  • A sitemap is a hint. Google may not crawl every URL in it.

What WordPress does by default

WordPress has had built-in sitemaps since version 5.5, at /wp-sitemap.xml, with one sitemap per content type and up to 2,000 URLs per sitemap page by default. Most SEO plugins replace the built-in sitemaps with their own. Either way, pages appear grouped by content type, not by campaign. Generated pages appear in those sitemaps like any other page, and a page generator that writes SEO fields into your SEO plugin keeps titles and robots settings in one place, as the SEO plugin guide describes.

Monitor indexing per page family

The question you want answered after a launch is not “are my pages indexed?” but “which family is not being indexed, and why?”. Two ways to get there:

  • Separate sitemaps per family. If your families live in different content types, they get separate sitemaps automatically, and Search Console’s page indexing report can be filtered by sitemap.
  • URL folder filters. If every family is a Page, they share one sitemap. Nested URLs then pay off again: filter Search Console reports by /areas/ or /services/ to see each family on its own.

Keep sitemaps clean. Leave out drafts, redirects, pages set to noindex and anything that does not return a 200 status. A sitemap full of URLs you do not want indexed sends a mixed message about the ones you do.

Crawl depth

Crawl depth is the number of clicks it takes to reach a page from the home page by following links. It is the most useful single number for judging a programmatic architecture, because it measures whether the structure actually connects the pages.

Calculate it

Take 1,200 generated pages and three ways to link them:

StructurePath to the deepest pageMaximum depthLongest list on one page
One hub, 50 links per page, paginatedHome β€Ί hub β€Ί next Γ— 23 β€Ί page2550
One hub, all on one pageHome β€Ί hub β€Ί page21,200
Areas β€Ί 4 states β€Ί 60 cities β€Ί pagesHome β€Ί areas β€Ί state β€Ί city β€Ί page4About 30

The second row looks shallow but fails in practice: nobody scans 1,200 links, and the page is heavy. The third row keeps every list short and every page four clicks from the home page. Linking the areas hub from the main navigation makes that same four-click path start from every page on the site, not only the home page.

Shortcuts that reduce depth

  • Link the top hubs from the navigation or footer, so the first level is one click from every page.
  • Cross-link siblings. A service page in Austin that links to the same service in Round Rock and Pflugerville gives those pages extra paths in.
  • Link from popular hand-built pages, such as a pricing page that links to the main service hubs.

Where crawl budget fits

Google’s crawl budget guide is written for very large sites: roughly a million or more unique pages that change about weekly, ten thousand or more that change daily, or sites with many URLs reported as “Discovered – currently not indexed”. Google says these are rough estimates, not exact thresholds.

Most programmatic WordPress sites are well below those numbers. Their problem is usually discovery and quality, not crawl capacity. The guide’s practices still apply at any size: consolidate duplicate URLs, return 404 or 410 for removed pages, eliminate soft 404s, keep sitemaps current and avoid long redirect chains. If a large share of a family sits in “Discovered – currently not indexed”, look at the pages themselves and at how they are linked before you look at the server.

Avoiding orphan pages

An orphan page is a published page that no other page on your site links to. It may be in the XML sitemap, but a visitor cannot reach it and search engines get no context for it.

How orphans appear in generated sets

  • Pages generated before their hub. The hub was planned and never built, or built without the new rows.
  • Hand-written hub lists that fall behind the data. Forty rows were added, the hub still lists the old ones.
  • A hub list that hits its limit. The block shows 1,000 links and the set has grown to 1,100.
  • Unpublished or noindex hubs. The children are live, the parent is a draft.
  • Links only in JavaScript widgets that do not render as <a href> links.
  • Removed parents. A city hub was deleted and its children kept.

Find them

  1. Export the list of published URLs from WordPress or your SEO plugin’s sitemap.
  2. Crawl the site from the home page with any site crawler, following links only, not the sitemap.
  3. Compare the two lists. Anything in the first list and missing from the crawl is an orphan.
  4. Group the orphans by family and parent. They almost always share a cause, such as one hub that is missing a group of rows.
  5. Fix the cause, then crawl again.

Run this after every large run, and on a schedule once the set is live.

Prevent them

  • Publish hubs first, and add the hub list in the same run that adds the pages.
  • Give every row the same number of related links, filled with final, published URLs.
  • Check the hub’s link count against the number of published pages in its group.

PageForge does not add internal links between generated pages automatically in the free plugin. It provides the hub list, the parent hierarchy and placeholders you can use in your own related-link columns. The internal linking guide shows the column pattern for nearby and related links.

Avoiding keyword cannibalization in large page sets

Keyword cannibalization is when several of your URLs compete for the same search, so none of them is clearly the best answer. In a programmatic set it rarely happens by accident on one page. It happens by design, in the data, across hundreds.

Where it comes from

CauseExampleFix
Synonym rows“Plumber Austin” and “Plumbers in Austin” as two rowsOne row, one URL
Two trees for the same combination/areas/austin/ac-repair/ and /services/ac-repair/austin/Keep one tree, link across from the other hub
A hub and its spoke chasing the same phraseThe Austin city hub and the Austin AC repair page both targeting “ac repair austin”The hub targets “hvac company austin”, the spoke targets “ac repair austin”
Modifier pages“Cheap”, “affordable” and “best” versions of one pageOne page that covers prices honestly
Neighborhood pages that match the city page“AC repair downtown Austin” with nothing that differs from the Austin pageMerge, or add facts that really differ
A blog post and a generated page on one question“AC repair cost in Austin” as a post and as the service page’s price sectionPick one owner, link the other to it

Keep a keyword-to-URL map

Before you generate, write down which URL answers which search. A few rows for one city:

Search intentThe one URL that answers it
hvac company austin/areas/texas/austin/
ac repair austin/areas/texas/austin/ac-repair/
emergency ac repair austin/areas/texas/austin/ac-repair/, in an emergency section
ac installation austin/areas/texas/austin/ac-installation/
ac repair, no place/services/ac-repair/

Every new row is checked against the map. If its intent already has a URL, the row is a section on that page, not a new page.

Find it after launch

In Search Console’s performance report, filter by a query and open the pages tab. If several of your URLs get impressions for the same query and trade places over time, they are competing. Check the top queries for each page family every month.

Fix it

  • Merge and redirect when two pages say the same thing. A permanent redirect is the clearest way to combine them.
  • Differentiate when both pages have a reason to exist, by giving each one facts and a focus the other does not have.
  • Use a canonical only for true duplicates, such as print versions or tracking-parameter URLs.
  • Remove the row from the data so the next run does not bring the page back.

Duplicate checks in page generators work on URLs. PageForge, for example, skips a row whose URL is already taken, but it cannot tell that two different URLs serve the same intent. That judgment stays with you, as the quality checklist points out.

A worked programmatic SEO site architecture: a 4-state HVAC company

Everything here is hypothetical. Say an HVAC company has crews in 60 cities across Texas, Oklahoma, Arkansas and Louisiana, and offers six services. Not every service is offered everywhere.

Count the pages

ServiceCities where it is offeredPages
AC repair6060
AC installation6060
Furnace repair6060
Heat pump service4545
Duct cleaning4040
Indoor air quality2525
Service and city pages290

Add the hubs: 1 areas hub, 4 state hubs, 60 city hubs, 1 services hub and 6 service hubs, which is 72. The full set is 362 pages. Multiplying 60 cities by 6 services would have produced 360 service pages on their own, 70 of them for services the local crew does not offer.

By state, the service and city pages split as Texas 137, Oklahoma 68, Arkansas 47 and Louisiana 38. Texas has 28 cities, Oklahoma 14, Arkansas 10 and Louisiana 8.

The tree

/                                         home (Areas and Services in the main navigation)
β”œβ”€β”€ /areas/                               1 hub, 4 links
β”‚   β”œβ”€β”€ /areas/texas/                     28 city links
β”‚   β”‚   β”œβ”€β”€ /areas/texas/austin/          up to 6 service links, plus 3 nearby cities
β”‚   β”‚   β”‚   β”œβ”€β”€ /areas/texas/austin/ac-repair/
β”‚   β”‚   β”‚   β”œβ”€β”€ /areas/texas/austin/heat-pump-service/
β”‚   β”‚   β”‚   └── ...
β”‚   β”‚   └── ... 27 more cities
β”‚   β”œβ”€β”€ /areas/oklahoma/                  14 city links
β”‚   β”œβ”€β”€ /areas/arkansas/                  10 city links
β”‚   └── /areas/louisiana/                 8 city links
└── /services/                            1 hub, 6 links
    β”œβ”€β”€ /services/ac-repair/              60 links, grouped by state
    └── ... 5 more services

Check the depth and the hub sizes

  • Through the areas path: home β€Ί areas β€Ί Texas β€Ί Austin β€Ί AC repair is 4 clicks. Because Areas is in the main navigation, the same 4 clicks work from any page on the site.
  • Through the services path: home β€Ί AC repair hub β€Ί Austin AC repair is 2 clicks.
  • The longest list is the AC repair service hub at 60 links, split into 4 state groups. No hub needs pagination.

Links on each page

PageLinks upLinks acrossLinks down
Service and city pageCity hub, through breadcrumbs and an in-page link, plus the service hubThe same service in 2 or 3 nearby cities, from columnsBooking
City hubState hub3 nearby city hubsIts 3 to 6 service pages
State hubAreas hubNeighboring state hubsIts city hubs
Service hubServices hubRelated servicesEvery city’s page for that service

Sitemaps and monitoring

All 362 pages are WordPress Pages, so they share one page sitemap with the site’s other pages, well under the 2,000-URL default of WordPress core sitemaps and far under Google’s 50,000 limit. The team monitors indexing with folder filters: /areas/texas/, /areas/oklahoma/ and so on, and /services/.

After launch, a crawl from the home page finds 359 of the 362 published URLs. The 3 missing pages are city hubs that were left off the hand-written Louisiana state hub. Adding them fixes the orphans, and they are added to the launch checklist for the next state.

Building it in WordPress

With PageForge Pro, the build is one template per page type. State hubs are written by hand. City hubs come from a 60-row file with a Parent Path column such as areas/texas. The 290 service pages come from one file with a Parent Path column such as areas/texas/austin, run after the city hubs exist. Check and preview shows the first page as “AC Repair in Austin, TX” at /areas/texas/austin/ac-repair/. With the Pro scheduler, the pages can go live up to a daily limit, so the hubs and nearby links keep pace. See the page scheduler.

In the free plugin, each template has one parent, so the team adapts the tree. City hubs go under their state hub, one template and file per state. Service pages also go under their state hub, again one template per state, with the city in the slug, such as /areas/texas/ac-repair-austin/, so the breadcrumb still reads Home β€Ί Areas β€Ί Texas β€Ί AC Repair in Austin, TX. At up to 100 rows per run, the Texas file splits into two runs of 100 and 37, and the other three states take one run each. The Free vs Pro comparison lists the differences that matter for structures like this.

Step-by-step: designing a programmatic SEO site architecture

  1. List the page families. Every pattern you plan to generate, such as service and city pages, city hubs and service hubs.
  2. Choose the dimension order and one URL pattern per family. Write the patterns down.
  3. Draw the tree with real counts at every level, as in the worked example.
  4. Calculate crawl depth for the deepest page and the length of the longest hub list. Split hubs that run long before you think about pagination.
  5. Build the keyword-to-URL map and remove rows whose intent already has a URL.
  6. Plan the links on each page type: up, across and down.
  7. Decide where breadcrumbs come from and check they will follow the parents.
  8. Plan sitemaps and monitoring: separate sitemaps, or folder filters.
  9. Build top-down. Publish the hubs, then generate a few children as drafts and check their paths.
  10. Launch by family or region, crawl after each group, fix orphans, then continue.

An AI planning tool can help with steps 1 to 3, as long as you check its suggestions against real searches. The AI site planner turns a business description into a proposed sitemap and the columns a CSV needs.

Common mistakes

  • Generating first, structuring later. Hundreds of pages appear at the root and the hubs never catch up.
  • Two trees for one page set. Place-first and service-first URLs for the same combinations.
  • Hubs that are bare lists. No introduction, no grouping, no facts, just 300 links.
  • One giant hub. Everything on one page, too long to use, or paginated so deep that the last items sit 25 clicks away.
  • Canonicalizing paginated hub pages to page 1. Items on later pages lose their only link path.
  • Changing slug patterns on live pages without redirects.
  • Sitemaps full of drafts, redirects and noindex pages.
  • Assuming the sitemap is enough. Pages that exist only in the sitemap are orphans.
  • Synonym and modifier rows that create several pages for one intent.
  • Breadcrumbs that ignore the hierarchy, because pages were generated flat with no parents.

The underlying quality question, whether each page deserves to exist, is covered in programmatic SEO without thin pages.

FAQ

What is programmatic SEO site architecture?

Programmatic SEO site architecture is the plan for where generated pages live, how they are grouped under hub pages, and how they link to each other. It covers URL patterns, parent pages, breadcrumbs, hub pagination, sitemaps and crawl depth. Its purpose is that every page has one parent, a path from the home page and a single search intent no other page competes for.

Should programmatic pages use flat or nested URLs?

Nested URLs suit most sets larger than a few dozen pages. They group pages in folders you can filter in reports, give breadcrumbs a hierarchy to follow and make hubs natural parents. Flat URLs are fine for small sets or when every page shares one parent. Whichever you choose, choose before you generate, because changing it later means redirecting every page.

How many clicks from the home page is too deep?

Aim to keep every generated page within about four clicks of the home page. There is no official limit, but deep pages tend to be found later and visited less. Calculate the deepest path through your hubs, including pagination. If it runs past four or five, add a level of hubs, link the top hub from the navigation or cross-link siblings.

Do I need hub pages if I have an XML sitemap?

Yes. A sitemap is a hint to search engines about which URLs exist, and Google says it may not crawl everything listed. It does nothing for visitors and gives no context about how pages relate. Hub pages link every generated page from the site itself, group them in a way people can use, and pass context from the hub to each page.

How should I paginate a hub with hundreds of links?

First try to split it by a second dimension, such as state, category or first letter. If pagination is still needed, give every page its own URL, link the pages in sequence with ordinary links, let each page be its own canonical and avoid URL fragments. Google no longer uses rel next and prev, so do not rely on them.

How do I find orphan pages in a large page set?

Compare two lists. Export every published URL from WordPress or your sitemap, then crawl the site from the home page following links only. URLs in the first list that the crawl never reached are orphans. Group them by parent or family to find the shared cause, usually a hub that is missing rows, fix it, and crawl again.

How do I stop programmatic pages from cannibalizing each other?

Keep a keyword-to-URL map and check every new row against it before you generate. Remove synonym and modifier rows, build only one URL tree, and give hubs the broad phrase and spokes the specific one. After launch, check Search Console for queries where several of your URLs get impressions, then merge, redirect or differentiate the pages involved.

Conclusion

A programmatic SEO site architecture is decided before the first page is generated: the URL pattern, the tree of hubs, the links on each page type, the breadcrumb source, the sitemap plan and the keyword-to-URL map. Draw it with real counts, calculate the depth, and build from the top down so every page arrives with a parent and a path.

Your next step is to draw the tree for your own page set, with the number of pages at each level, and check the deepest path. Then read the internal linking guide to plan the links that tie each level together.

Programmatic SEO notes, once a month

New guides, templates and PageForge releases. No spam, unsubscribe in one click.

Build the template once. Let the data do the rest.

PageForge is free on WordPress.org. Upload a CSV, preview the first page, and generate your first 100 pages today.

↑↓ to move↡ to open