Complete programmatic SEO case study: 250K monthly organic visitors from 12,000 auto-generated pages. The framework, tools, and pitfalls for B2B SaaS startups.
TL;DR
Most SaaS companies approach SEO the hard way: Write one blog post, rank for one keyword, get some traffic. Repeat 100 times.
What if you could write one template and generate 10,000 pages -each targeting a different long-tail keyword?
That's programmatic SEO. And it's how we went from 8K monthly organic visitors to 258K in 14 months.
The strategy: Create data-driven page templates that automatically generate thousands of unique, valuable pages. Each page targets a specific long-tail search query. Scale content without scaling headcount.
This is our complete case study -what we built, how we built it, what worked, what failed, and the exact framework you can replicate.
Programmatic SEO: Using templates + structured data to automatically generate hundreds or thousands of landing pages, each targeting a specific search query.
The formula:
Template (1) × Data Source (10,000 rows) = 10,000 unique pages
Classic examples:
Zillow:
Canva:
Nomad List:
Why it works for SaaS:
Long-tail dominance: 70% of searches are long-tail (3+ words). Programmatic SEO captures these.
Compound growth: Each page might only get 50 visitors/month. But 10,000 pages × 50 = 500K visits/month.
Low competition: Most companies won't create 10,000 pages manually. Less competition in long-tail.
Scalable: Once template is built, adding 1,000 more pages takes minutes, not months.
Company: B2B SaaS platform (similar to Zapier/Make.com) Challenge: Rank for "[Tool A] + [Tool B] integration" searches Opportunity: 15,000+ integration combinations = 15,000 potential pages
The strategy:
Template: "[Tool A] + [Tool B] Integration: How to Connect in [X] Steps"
Data source:
Math:
Step 1: Validate search demand
Used Ahrefs to check search volume for integration keywords:
| Keyword Pattern | Example | Monthly Searches | Competition |
|---|---|---|---|
| [Tool A] [Tool B] integration | "Slack Gmail integration" | 480 | Low |
| [Tool A] to [Tool B] | "Slack to Gmail" | 320 | Low |
| connect [Tool A] with [Tool B] | "connect Slack with Gmail" | 180 | Low |
| [Tool A] [Tool B] automation | "Slack Gmail automation" | 240 | Medium |
Finding: 12,400 integration combinations × average 220 searches/month = 2.7M monthly search volume potential
Step 2: Analyze competition
Checked top 10 results for 50 sample queries:
Opportunity: 60% of results were beatable with quality content.
Step 3: Define page template structure
URL: /integrations/[tool-a]-[tool-b]
H1: [Tool A] + [Tool B] Integration: Connect in [X] Steps
Sections:
1. Overview (what this integration does)
2. Prerequisites (what you need)
3. Step-by-step setup (with screenshots)
4. Popular use cases (3-5 examples)
5. Troubleshooting (common issues)
6. Related integrations (internal links)
7. FAQ (schema markup)
Challenge: Make 12,400 pages feel unique, not spammy duplicates.
Solution: Dynamic content blocks based on data
Static content (same on all pages):
Dynamic content (unique per page):
The data structure:
{
"tool_a": "Slack",
"tool_b": "Gmail",
"category_a": "Communication",
"category_b": "Email",
"complexity": "Easy",
"setup_time": "5 minutes",
"use_cases": [
"Get Slack notifications for important emails",
"Send emails from Slack channels",
"Create email drafts from Slack messages"
],
"template_count": 47,
"setup_steps": [
"Connect your Slack account",
"Authorize Gmail access",
"Choose trigger and action",
"Map fields and test"
]
}
Template rendering:
// Simplified template logic
function generateIntegrationPage(toolA, toolB, data) {
return `
<h1>${toolA} + ${toolB} Integration: Connect in ${data.setup_steps.length} Steps</h1>
<p>Connect ${toolA} (${data.category_a}) with ${toolB} (${data.category_b}) to automate workflows.</p>
<div class="complexity">
Setup complexity: ${data.complexity} | Time: ~${data.setup_time}
</div>
<h2>Popular Use Cases</h2>
<ul>
${data.use_cases.map(uc => `<li>${uc}</li>`).join('')}
</ul>
<h2>How to Set Up</h2>
${data.setup_steps.map((step, i) => `
<h3>Step ${i+1}: ${step}</h3>
[Dynamic content explaining step]
`).join('')}
<h2>${data.template_count} Pre-Built Templates</h2>
[Grid of user templates using this integration]
[Related integrations, FAQ, etc.]
`;
}
Problem: Initial pages were "meh" -technically unique but lacking depth.
Google's perspective: Just because pages are unique doesn't mean they're valuable.
Enhancement strategy:
Added user-generated content:
Enriched use cases:
Added visual elements:
Schema markup:
Month 7-8: Indexing challenges
Problem: Google only indexed 2,400 of 12,400 pages initially.
Why:
Solutions:
Result: Month 10: 9,200 pages indexed (74%)
Month 9-12: Rankings improved
Early results (Month 9):
After optimization (Month 12):
What drove improvement:
Traffic:
Engagement:
Business impact:
Cost:
Here's how to replicate this for your product.
What data do you have that could become pages?
Common SaaS data sources:
| SaaS Type | Data Source | Example Pages |
|---|---|---|
| Integration platform | Supported integrations | "[Tool A] + [Tool B] integration" |
| Job board | Jobs × locations | "Software engineer jobs in Manchester" |
| Directory | Listed companies/products | "[Category] tools for [use case]" |
| Comparison tool | Product combinations | "[Product A] vs [Product B]" |
| Template marketplace | Templates × categories | "[Use case] [format] template" |
| Analytics tool | Metrics × industries | "[Metric] benchmarks for [industry]" |
Your exercise:
What unique data do you have access to that your competitors don't?
For us: Our platform knew which tools integrate with which, and we had user-generated workflow templates.
Don't build pages for keywords nobody searches.
Validation process:
Sample 50 potential pages
Check search volume
Calculate potential
Check competition
Red flags:
Green lights:
A good programmatic template has:
Unique H1 with target keyword
[Keyword variable 1] + [Keyword variable 2]: [Value prop]
Structured sections (not just keyword-stuffed fluff)
Dynamic content blocks
User-generated elements (if possible)
Template quality checklist:
Option A: Custom build
Tech stack we used:
Build process:
// pages/integrations/[toolA]-[toolB].js
export async function getStaticPaths() {
// Generate all possible integration combinations
const integrations = await getIntegrationPairs();
return {
paths: integrations.map(int => ({
params: {
toolA: int.tool_a.slug,
toolB: int.tool_b.slug
}
})),
fallback: false
};
}
export async function getStaticProps({ params }) {
// Fetch data for this specific integration
const data = await getIntegrationData(params.toolA, params.toolB);
return {
props: { data }
};
}
Option B: No-code/low-code
Tools:
The challenge: How do you make 10,000 pages high-quality?
The 80/20 approach:
Top 20% (2,000 pages): High-value keywords, manually enriched
Bottom 80% (8,000 pages): Template-driven, good enough
Our content tiers:
| Tier | Pages | Search Vol | Content Approach | Investment |
|---|---|---|---|---|
| Tier 1 | 500 | 300+/mo | Fully custom written | £24/page |
| Tier 2 | 2,000 | 100-300/mo | AI + human editing | £8/page |
| Tier 3 | 9,900 | <100/mo | Template + data only | £0.20/page |
Total content cost: £44,500 for 12,400 pages = £3.58/page average
Google won't index everything immediately.
Crawl budget optimization:
XML Sitemap with priorities
<url>
<loc>https://yoursite.com/integrations/slack-gmail</loc>
<priority>0.9</priority> <!-- High-value page -->
</url>
<url>
<loc>https://yoursite.com/integrations/obscure-tool-a-obscure-tool-b</loc>
<priority>0.3</priority> <!-- Low-value page -->
</url>
Internal linking structure
Gradual rollout
Request indexing for top pages
The mistake: Creating 10,000 pages with 200 words each.
Why it fails: Google sees this as low-quality spam.
The fix:
Our rule: If you wouldn't want to read it, don't publish it.
The mistake: Creating multiple pages targeting the same keyword.
Example:
/integrations/slack-gmail/integrations/gmail-slack/blog/how-to-integrate-slack-and-gmailAll three compete for "Slack Gmail integration."
The fix:
The mistake: Focusing only on SEO, not usability.
Red flags:
The fix:
The mistake: Your programmatic pages are identical to competitors' programmatic pages.
Why it fails: If 5 sites all have the same template for "Slack Gmail integration," Google picks one (probably not you).
The fix: Add something competitors don't have
Our differentiator: We had 20,000+ user-generated workflow templates. Competitors had generic how-tos.
The mistake: One bug × 10,000 pages = 10,000 broken pages.
Examples we encountered:
The fix:
Our investment:
| Category | Cost |
|---|---|
| Development (template + infrastructure) | £18,000 |
| Content creation (tiered approach) | £44,500 |
| Design/UX | £8,000 |
| Ongoing maintenance (Year 1) | £24,000 |
| Total Year 1 | £94,500 |
Our returns (Year 1):
| Metric | Value |
|---|---|
| Organic visitors/month (avg) | 175,600 |
| Signups/month (avg) | 6,240 |
| Conversion to paid (24%) | 1,498/year |
| Average LTV | £560 |
| Revenue influenced | £838,880 |
ROI: 788%
But wait -what about ongoing value?
Year 2 (minimal ongoing costs):
Programmatic SEO compounds. Once pages rank, they generate traffic for years with minimal ongoing investment.
Week 1: Research
Week 2-3: Validation
Week 4-6: Template design
Week 7-10: Build
Week 11-12: Content creation
Month 4: Launch
Month 5-6: Scale
Month 7-12: Optimize
Expected timeline to results: 6-9 months for meaningful traffic
Programmatic SEO is a good fit if:
✅ You have a rich, structured data source (integrations, locations, products, etc.) ✅ There's search demand for variations of that data ✅ You can create genuinely valuable pages (not thin content) ✅ You have development resources (or budget for no-code tools) ✅ You're playing a long game (6-12 months to see ROI)
Programmatic SEO is NOT a good fit if:
❌ You don't have unique data ❌ No one is searching for variations of your pages ❌ You can't beat current top 10 results ❌ You need traffic in next 30 days (it takes time) ❌ You're not willing to maintain pages long-term
Alternative strategies if programmatic SEO isn't right:
Trends we're seeing:
AI-generated content (more sophisticated)
User-generated content (even more valuable)
Video and rich media (differentiation)
Hyper-personalization (next frontier)
Our next phase:
We're adding:
Want to implement programmatic SEO for your SaaS? Athenic can help identify your data source, generate page templates, and auto-create thousands of optimized landing pages -with built-in quality checks and schema markup. See how it works →
Related reading: