# Programmatic page brief template

> The brief engineers and writers need before a page set ships: data fields, unique value block, URL pattern, internal links, QA gates and written kill criteria.

Source: https://saas-marketing.net/templates/programmatic-page-brief-template/
Topic: SaaS SEO
Type: template
Published: 2026-09-11
Last updated: 2026-09-11
Publisher: SaaS Marketing (saas-marketing.net)
License: CC BY 4.0. Quote or republish with attribution and a link to https://saas-marketing.net/templates/programmatic-page-brief-template/

## Short answer

A programmatic page brief is the specification handed to engineering before a templated page set is built. It defines the entity and modifier pair, the data source and its refresh frequency, field level mapping from data to on page elements, a mandatory unique value block with a minimum data point count, URL and title patterns, internal link rules, sitemap segmentation, numeric indexation gates and written kill criteria that trigger a noindex.

## Key takeaways

- A page set without written kill criteria should not be approved, because nobody volunteers to delete 4,000 pages later.
- Specify a minimum unique data point count per page, typically five, and fail the build when a record cannot meet it.
- Ship in batches of 25 to 50, measure indexation at six weeks, and only scale when more than 60 percent are indexed.
- Every templated page needs at least one inbound internal link from an editorial page, or it will sit uncrawled.
- Give each page set its own sitemap file so you can read indexation by template rather than by guesswork.
- The data refresh frequency belongs in the brief, since stale pricing or stale integration fields create legal and trust problems.

---

The reason most templated page sets underperform has nothing to do with Google's tolerance for scale. It is that an SEO lead described the idea in a Slack thread, an engineer built a reasonable interpretation of it, and neither of them agreed in writing what a page must contain to be allowed to exist. This brief is the artifact that fixes that. Ten blocks, signed off by both sides before a single row of the data table becomes a URL.

## The ten blocks, and who signs each one

Print this table at the top of the brief. If a block is empty, the set is not approved.

| # | Block | Owner | Sign off |
| --- | --- | --- | --- |
| 1 | Entity and modifier definition | SEO | SEO lead |
| 2 | Data source and refresh frequency | Data or engineering | Engineering |
| 3 | Field to element mapping | SEO | Both |
| 4 | Unique value block and minimum data points | SEO and product | SEO lead |
| 5 | URL, title and meta patterns | SEO | Engineering |
| 6 | Internal link rules, inbound and outbound | SEO | Both |
| 7 | Render mode and performance budget | Engineering | Engineering |
| 8 | Sitemap segmentation | Engineering | SEO lead |
| 9 | Indexation gates with numeric thresholds | SEO | Head of marketing |
| 10 | Kill criteria | SEO | Head of marketing |

Blocks 9 and 10 are the ones that get skipped, and they are the two that decide whether this becomes an asset or a liability. Read the [programmatic page indexation study](/research/programmatic-page-indexation-study/) before you argue for skipping them.

## Block 1: define the entity and the modifier precisely

Every programmatic set is one entity crossed with one modifier list. Write both as a set, with the exclusion rules attached.

```
Entity: App in our integrations catalogue (source: integrations table, 312 rows)
Modifier: Our product name (single value, not a cross product)
Pattern: [our product] + [app] integration
Exclusions: apps with fewer than 4 synced fields
 apps in private beta
 apps whose vendor name is a registered trademark we cannot use in a title
Resulting set: 312 rows minus 84 exclusions = 228 pages
```

The exclusion list is where the quality gate starts. Write the arithmetic out, because the difference between 312 and 228 is the difference between a set that can be defended and one that cannot. This is the same discipline that separates [programmatic and editorial content](/comparisons/programmatic-vs-editorial-content/) as production models.

## Block 2: data source and refresh frequency

Name the table, the owner and the cadence. Stale data on a scaled page set is a legal exposure, not a ranking problem, particularly on anything showing competitor pricing.

| Field | Source | Refresh | Breaks the page if stale |
| --- | --- | --- | --- |
| Synced field list | `integrations.fields` | Nightly | Yes |
| Sync direction | `integrations.direction` | Nightly | Yes |
| Setup time estimate | Product marketing, manual | Quarterly | No |
| Vendor logo and name | `vendors` table | Weekly | Yes |
| Known limitations | Support macros export | Monthly | No |
| Customer count using it | `usage_rollup` | Weekly | No |

For every field, say what the template does when the value is missing or null. Render a fallback sentence, hide the block, or refuse to build the page. Leaving this undefined is how you get 40 live pages reading `Setup time: undefined` on a Friday afternoon.

## Block 4: the unique value block and its floor

This is the block that decides indexation, and it is the one engineers push back on because it cannot be generated. Set a hard floor: five unique data points per page plus 120 words of page specific prose that no sibling page carries.

**Unique value floor for an integration page**

## Blocks 5 and 6: URL patterns and link rules

URLs first. Pick the pattern before anything is built, because changing it later means redirecting the whole set.

```
URL: /integrations/[app-slug]/
Title: [App name] integration for [Product] | Two way sync in [X] minutes
H1: [Product] and [App name] integration
Meta: Connect [Product] to [App name]. Sync [field count] fields two ways,
 set up in [X] minutes, no code required.
Canonical: self, absolute
```

Now link rules, which are where most sets quietly fail. Inbound: every templated page needs at least one link from an editorial page or a hub, because a page reachable only from a sitemap gets crawled late and often not at all. Outbound: three to five links back, split between the parent hub, two sibling pages chosen by shared category rather than alphabetically, and one relevant guide.

| Rule | Requirement | Enforced by |
| --- | --- | --- |
| Inbound from hub | 1 per page, from `/integrations/` index | Template |
| Inbound from editorial | At least 1 across the top 40 pages by volume | Manual, tracked in the map |
| Outbound siblings | 2 to 4, category matched | Template |
| Outbound to guide | 1, mapped by category | Template |
| Anchor text | Vendor name plus the word integration | Template |
| Max links per page | 60 including nav | QA crawl |

Keep the parent hub page in your [SaaS keyword map template](/templates/saas-keyword-map-template/) as a single row representing the whole set, rather than 228 rows nobody will maintain.

## Blocks 8 and 9: sitemap segmentation and numeric indexation gates

One sitemap file per template, referenced from a sitemap index. Search Console reports coverage per sitemap, so this is the difference between knowing your integration pages sit at 78% and your use case pages at 11%, and staring at one blended number that tells you nothing.

Then the gates. Write numbers, not intentions.

**60%** Indexed share required at week six before a programmatic set is allowed to scale past the first batch

The operational side of running these batches sits in the [programmatic page launch playbook](/playbooks/programmatic-page-launch/), and the strategy case for doing any of this is in the [programmatic SEO for SaaS](/guides/programmatic-seo-for-saas/) guide.

## Block 10: kill criteria, written before launch

Here is the position this template exists to argue. A page set without written kill criteria should not be approved. Nobody ever volunteers to delete 4,000 pages, because by then the set has a champion, a slide in a QBR and a traffic number that looks fine until you segment it.

So write the conditions now, while nobody is attached to them.

**The five kill conditions**

Attach an owner and a review date to the criteria themselves. Quarterly is enough. The review takes twenty minutes and consists of running five queries against Search Console and the data warehouse.

## A filled example: the integration set

Pulling it together for the 228 page integration set described above. Entity: apps in the catalogue with four or more synced fields. Data refreshed nightly from the integrations table, with setup times maintained quarterly by product marketing. Each page carries the synced field list, sync direction, setup time, two limitations, one screenshot and a named use case, which clears the five point floor.

URLs follow `/integrations/[app-slug]/`, server rendered, self canonical, in a dedicated `sitemap-integrations.xml`. Every page links up to the integrations hub and across to two category siblings. Batch one covers the 40 apps with the highest search volume, including Slack, Stripe and HubSpot, which also happen to be the ones with the richest field data.

Gates: 60% indexed at week six or the rollout halts. Kill criteria as above, reviewed each quarter by the SEO lead. Modelled pipeline for the full set runs through the [SaaS SEO ROI calculator](/calculators/saas-seo-roi/) at three conversion tiers, because integration intent converts far better than the volume suggests. The detailed page anatomy lives in the [SaaS integration pages](/guides/saas-integration-pages-seo/) guide, and the same brief structure adapts to [alternatives pages](/guides/saas-alternatives-pages/) with the modifier swapped for competitor names.

## The honest cost

Writing this brief properly takes a day, and the unique value block takes longer than the engineering. For a 228 page set, budget two to three weeks of a writer and a product marketer producing the per page prose and screenshots, because that part cannot be generated from the table. Teams that skip it ship in four days and index at 12%.

## Before you approve anything

Fill blocks 1, 4, 9 and 10 first. If those four are weak the rest does not matter. Send the brief to the engineer who will build it and ask them to reject anything ambiguous rather than interpret it. Then launch 40 pages, not 400, and put a calendar reminder six weeks out to check indexation. Definitions and background sit in the [programmatic SEO](/glossary/programmatic-seo/) entry and the wider [SaaS SEO](/saas-seo/) hub.

## Frequently asked questions

### What is a programmatic SEO brief?

It is the written specification that sits between the SEO lead and the engineer before a templated page set gets built. It covers the entity and modifier definition, the data source, how data maps to each on page element, what unique content every page must carry, the URL pattern, internal linking rules, indexation thresholds and the conditions under which pages get removed.

### How much unique content does a programmatic page need?

Set a floor of five unique data points per page that no sibling page shares, plus at least 120 words of genuinely page specific text. For an integration page that means the actual fields that sync, the direction of sync, setup time, known limitations and a real screenshot. Records that cannot hit the floor should not generate a page at all.

### Why do most programmatic SEO page sets fail to get indexed?

Three reasons dominate. The pages are near duplicates so Google treats them as one, they have no internal links pointing at them so crawlers never reach them at depth, and the set launches at 2,000 pages at once with no crawl history to justify the budget. Batch rollout, unique data blocks and internal links from editorial pages fix most of it.

### What are kill criteria for a programmatic page set?

Pre agreed numeric conditions that convert a page to noindex or remove it. Typical ones: fewer than five unique data points after a data refresh, zero impressions in Search Console over 120 days, an indexation rate below 40 percent across the batch at week twelve, or a source record deprecated upstream. Writing them before launch is what makes pruning possible later.

### Should programmatic pages go in their own sitemap?

Yes. Give each template its own sitemap file, referenced from a sitemap index. Search Console reports indexation per sitemap, so segmenting by template is the only cheap way to see that your integration pages are at 78 percent and your job title pages are at 11 percent. One combined sitemap hides exactly the signal you need.

### How many programmatic pages should you launch at once?

Start with 25 to 50 on a new domain or a new template. Wait six weeks, measure the indexed share, then scale in multiples only if it clears 60 percent. Launching the full set on day one removes your ability to diagnose whether a low indexation rate came from the template quality, the data thinness or the batch size.

### Who owns a programmatic page brief, SEO or engineering?

SEO writes it and engineering signs it off before any build starts. The brief is the contract: SEO commits to the data floor, the copy blocks and the kill criteria, engineering commits to the URL pattern, the render mode and the sitemap segmentation. Sets built from a Slack thread instead of a brief are the ones that ship with client side rendered content.