Most developers treat SEO like a dark art — something you hire a specialist for and hope for the best. But here's the truth: SEO is just structured data + automation + consistency. And if you can write a Python script, you can build a content engine that outranks sites with 10x your budget.
I've been running programmatic content pipelines for the past year, and in this post I'll show you exactly how to build one — from keyword research to publishing — using nothing but Python and a few open-source tools.
Why Programmatic SEO?
Traditional content creation doesn't scale. Writing one article at a time, manually researching keywords, and hand-crafting meta descriptions is a recipe for burnout. Programmatic SEO flips this model:
Research once, generate many. Build a keyword database, then template your content.
Optimize at the template level. Get your on-page SEO right in the code, not in a checklist.
Publish consistently. Search engines reward sites that publish regularly. A content engine never misses a day.
Here's what our pipeline looks like:
Keyword Research → Content Planning → Template Rendering → SEO Validation → Publishing
Each stage is a Python module. Let's walk through them.
Step 1: Keyword Research with Python
Forget expensive tools. You can build a solid keyword list using free APIs and some clever scraping.
import requests
from typing import List, Dict
def fetch_related_queries(seed_keyword: str, limit: int = 50) -> List[Dict]:
"""Fetch related search queries using Google's Suggest API."""
url = "https://suggestqueries.google.com/complete/search"
params = {
"client": "firefox",
"q": seed_keyword,
"hl": "en",
}
resp = requests.get(url, params=params)
suggestions = resp.json()[1]
keywords = []
for kw in suggestions[:limit]:
keywords.append({
"keyword": kw,
"seed": seed_keyword,
"intent": classify_intent(kw), # informational, transactional, etc.
})
return keywords
def classify_intent(keyword: str) -> str:
"""Simple intent classifier based on keyword patterns."""
transactional = ["buy", "price", "discount", "deal", "cheap", "review"]
if any(t in keyword.lower() for t in transactional):
return "transactional"
return "informational"
Store your keywords in SQLite — it's battle-tested and requires zero setup:
import sqlite3
def init_keyword_db(db_path: str = "keywords.db"):
conn = sqlite3.connect(db_path)
conn.execute("""
CREATE TABLE IF NOT EXISTS keywords (
id INTEGER PRIMARY KEY,
keyword TEXT UNIQUE,
seed TEXT,
intent TEXT,
search_volume INTEGER DEFAULT 0,
difficulty INTEGER DEFAULT 0,
content_status TEXT DEFAULT 'pending',
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
""")
conn.commit()
return conn
Step 2: Content Generation with Templates
The magic of programmatic SEO is in the templates. Instead of writing each article from scratch, you create data-driven templates that pull from your keyword database and render unique, valuable content.
Here's a Python template engine using Jinja2:
from jinja2 import Template
from datetime import datetime
tutorial_template = Template("""
# {{ title }}
**Last updated:** {{ date }}
{{ intro }}
## What You'll Learn
{% for item in learning_points %}
- {{ item }}
{% endfor %}
## Step-by-Step Guide
{% for step in steps %}
### {{ loop.index }}. {{ step.heading }}
{{ step.content }}
python
{{ step.code }}
{% endfor %}
## Common Pitfalls
{% for pitfall in pitfalls %}
> **⚠️ {{ pitfall.title }}:** {{ pitfall.description }}
{% endfor %}
## Key Takeaways
{% for takeaway in takeaways %}
- {{ takeaway }}
{% endfor %}
""")
def render_article(keyword_data: dict, content_brief: dict) -> str:
"""Render a complete article from keyword data and a content brief."""
return tutorial_template.render(
title=content_brief["title"],
date=datetime.now().strftime("%B %d, %Y"),
intro=content_brief["intro"],
learning_points=content_brief["learning_points"],
steps=content_brief["steps"],
pitfalls=content_brief.get("pitfalls", []),
takeaways=content_brief["takeaways"],
)
python
Step 3: SEO Validation Layer
Before publishing, every article runs through a validation pipeline that checks:
Title length (50-60 characters for SERP display)
Meta description (150-160 characters)
Keyword density (0.5-2% target range)
Heading hierarchy (exactly one H1, proper nesting)
Internal/external link count (minimum thresholds)
Readability score (Flesch-Kincaid grade level 7-9)
import re
from collections import Counter
def validate_seo(markdown_content: str, target_keyword: str) -> dict:
"""Run SEO checks on rendered content and return a report."""
checks = {}
# Extract H1
h1_match = re.search(r'^# (.+)$', markdown_content, re.MULTILINE)
title = h1_match.group(1) if h1_match else ""
checks["title_length"] = {
"value": len(title),
"pass": 50 <= len(title) <= 60,
"recommendation": "50-60 characters"
}
# Keyword density
words = markdown_content.lower().split()
keyword_count = sum(1 for w in words if target_keyword.lower() in w)
density = (keyword_count / len(words)) * 100 if words else 0
checks["keyword_density"] = {
"value": round(density, 2),
"pass": 0.5 <= density <= 2.0,
"recommendation": "0.5% - 2.0%"
}
# Link count
link_count = len(re.findall(r'\[.+?\]\(https?://.+?\)', markdown_content))
checks["external_links"] = {
"value": link_count,
"pass": link_count >= 2,
"recommendation": "at least 2 external links"
}
checks["all_pass"] = all(c["pass"] for c in checks.values() if isinstance(c, dict) and "pass" in c)
return checks
Step 4: Automated Publishing Pipeline
Tie everything together with a publisher that handles multiple platforms:
import requests
from typing import Optional
class ContentPublisher:
def __init__(self, devto_api_key: str):
self.devto_key = devto_api_key
self.session = requests.Session()
def publish_to_devto(self, title: str, markdown: str, tags: list) -> Optional[str]:
"""Publish an article to dev.to via the Forem API."""
payload = {
"article": {
"title": title,
"body_markdown": markdown,
"published": True,
"tags": tags[:4], # dev.to limit
}
}
resp = self.session.post(
"https://dev.to/api/articles",
headers={
"api-key": self.devto_key,
"Content-Type": "application/json",
},
json=payload,
)
if resp.status_code == 201:
data = resp.json()
return data.get("url")
raise RuntimeError(f"Publish failed: {resp.status_code} - {resp.text}")
def run_pipeline(self, articles: list) -> dict:
"""Run the full pipeline for a batch of articles."""
results = {"published": [], "failed": []}
for article in articles:
# Step 1: Render
rendered = render_article(article["keyword"], article["brief"])
# Step 2: Validate SEO
seo_report = validate_seo(rendered, article["keyword"]["keyword"])
if not seo_report["all_pass"]:
print(f"⚠️ SEO issues for '{article['title']}': {seo_report}")
# Step 3: Publish
try:
url = self.publish_to_devto(
article["title"], rendered, article.get("tags", [])
)
results["published"].append({"title": article["title"], "url": url})
except Exception as e:
results["failed"].append({"title": article["title"], "error": str(e)})
return results
Supercharge Your Pipeline with the Dev Content Toolkit
Building all of this from scratch works, but if you want to skip the boilerplate and get straight to publishing, check out the gives you a running start. Start small. Pick one content template (tutorials work great), build a keyword list of 20-30 related terms, and render + publish your first batch this week. Once you see the traffic curve start to bend upward, expand to more templates and more platforms. If you're looking for more tools to automate your developer workflow, check out the AI Agent Toolkit and the full collection at the store — there's something for every stage of your pipeline. Happy automating! 🚀
What's Next?
SOCIAL SHARE CARD GENERATOR