Entity-First Content Briefs: How We Stopped Writing for Keywords and Started Writing for the Knowledge Graph
Keyword-stuffed briefs stopped moving the needle in 2025. Here's the entity-first brief format we now ship to writers, and the small pipeline that generates it from GSC, SERP data, and a graph store.
Our writers used to get briefs that looked like SEMrush exports with a pulse: a primary keyword, ten secondaries, a word count, and a vague "cover these questions" section. The articles ranked, sometimes. Then Google's SERPs got more entity-aware, AI Overviews started pulling from structured passages, and our hit rate dropped. We rebuilt the brief format from the ground up around entities instead of keywords. This is what changed and how the pipeline works.
Why Keyword Briefs Quietly Stopped Working
A keyword brief tells a writer what phrase to repeat. An entity brief tells them what concepts must be present, how they relate, and what the page is actually about in machine-readable terms.
Google has been moving this direction for years — the Knowledge Graph, MUM, the shift toward passage-level retrieval — but the tipping point for us was watching AI Overviews cite pages that didn't even rank in the top ten. The common factor on those pages wasn't keyword density. It was clean entity coverage: a page about "headless commerce migration" that explicitly named the platforms, the API patterns, the trade-offs, and the adjacent concepts (PIM, OMS, edge rendering) in a way a retrieval model could chunk cleanly.
Our old briefs were optimising for a ranking model that was already two generations behind.
What an Entity-First Brief Contains
The format we ship now has five blocks. Writers push back on it less than the old one, because it reads more like a technical spec than a content checklist.
1. Primary Entity and Type
One entity, stated unambiguously, with its schema.org type. Not "keyword: kubernetes monitoring" but:
primary_entity:
name: "Kubernetes monitoring"
type: "SoftwarePractice"
wikidata_id: "Q109458462" # if available
disambiguation: "observability practice, not a specific product"
The disambiguation line matters. "Apache" could be the web server, the helicopter, or the foundation. Stating it up front stops the writer drifting into the wrong semantic neighbourhood.
2. Supporting Entity Graph
A list of 15 – 30 related entities, each tagged with a relationship type and a coverage requirement.
supporting_entities:
- name: "Prometheus"
relation: "tool_used_for"
coverage: "must_mention"
- name: "OpenTelemetry"
relation: "standard_related_to"
coverage: "must_explain"
- name: "cardinality explosion"
relation: "problem_in"
coverage: "should_mention"
must_explain means the writer needs at least a paragraph defining the entity and its relationship to the primary. must_mention is a sentence. should_mention is optional but earns points in our internal brief score.
3. Questions, Framed as Passage Targets
Not a flat list of PAA questions. Each question is paired with the entities it should connect, because that's how retrieval models chunk answers.
passages:
- question: "How do you reduce Prometheus cardinality?"
must_connect: ["Prometheus", "cardinality explosion", "label hygiene"]
target_length: "80-150 words"
4. Schema Payload
The JSON-LD the page will ship with, drafted at brief time, not bolted on after. If the brief can't produce a clean Article + about + mentions payload, the topic is probably too vague.
5. Internal Link Targets
Two or three existing pages on the site that share entities with this one, pulled from our internal entity graph. Writers link to them naturally rather than at the end as an afterthought.
The Pipeline That Generates the Brief
We don't write these by hand. The brief is assembled by a small Python service that pulls from four sources and hands a draft YAML to the editor. The editor still edits — this is not a vibes-to-publish machine — but the first 70% is automated.
Source 1: GSC Query Data
For existing clusters, we pull queries from the GSC API filtered by the URL pattern of the cluster. We group queries by stemmed intent and extract noun phrases using spaCy. Those noun phrases are candidate entities.
Source 2: SERP Entity Extraction
We fetch the top 10 results for the primary keyword (via a SERP API, not scraping Google directly) and run the visible body text through an entity linker. We've used both spaCy's entityLinker and a small fine-tuned model that maps to Wikidata IDs. The output is a frequency map: entities that appear on 6+ of 10 ranking pages are strong candidates for must_mention.
from collections import Counter
def rank_entities(serp_pages):
counter = Counter()
for page in serp_pages:
entities = link_entities(page.text)
counter.update({e.wikidata_id for e in entities})
return [
(eid, count) for eid, count in counter.most_common()
if count >= 6
]
Source 3: Our Internal Entity Graph
Every published article writes its entities and their relationships into a small Neo4j instance. When we brief a new article, we query the graph for entities that are one or two hops from the primary — these become candidate internal link targets and often surface supporting entities the SERP scrape missed.
Source 4: Wikidata for Disambiguation
A quick lookup against Wikidata gives us the canonical label, the type, and the description. This is what fills the disambiguation field and prevents the writer from conflating entities with similar surface forms.
The four sources get merged, deduplicated, and scored. Anything above a threshold lands in the brief. Everything else goes into an "inspiration" section the writer can ignore.
What Changed When We Shipped This
Two things we did not expect.
First, the writers got faster. Counter-intuitive — the brief is denser — but the ambiguity is gone. They're not guessing what to cover. Our average time-to-draft on a 1,500-word article dropped noticeably once writers adapted to the format (give it three or four articles; the first one is always rough).
Second, the pages started getting cited in AI Overviews and in the "from sources across the web" blocks more often than their ranking position would predict. That's the entity coverage paying off. The pages chunk well because they were written to chunk well.
Ranking-wise, we saw lifts in the kind of mid-tail queries where the SERP is a mess of thin competitors — exactly where entity completeness is a cheap edge. Head terms moved more slowly, as you'd expect, because those SERPs are dominated by authority signals the brief format can't fix.
Where This Breaks
Three honest failure modes.
Brand and product pages. Entity-first briefs assume there's a real concept to anchor to. For a product landing page targeting "[brand] alternative" queries, the entity graph is thin and the brief is overkill. We use the old format there.
Topics with weak Wikidata coverage. Emerging tech (anything that was named in the last 18 months) often has no Wikidata entry, no clean disambiguation, and a noisy SERP. The pipeline produces junk. We hand-write those briefs.
Writers who confuse coverage with padding. The brief asks for entity coverage, not entity dumping. If every supporting entity gets a two-sentence drive-by mention, the article reads like a glossary. We added a style note to the brief template: "integrate, don't enumerate." It helped.
What We'd Do If Starting Tomorrow
Start small. Pick one content cluster — ideally one where you've got decent GSC history and middling rankings — and rewrite five briefs in the entity-first format by hand. Don't build the pipeline yet. You need to feel the format before you automate it, or you'll automate the wrong thing.
Once the manual version is working and your writers aren't rebelling, build the SERP entity extraction step first. It gives you 60% of the value for 20% of the effort. The internal graph and the Wikidata lookups can wait until you've got 50+ briefs and the gaps start showing.
If you want help wiring this into an existing content engine, we've done the build-out a few times and our SEO and content engineering work is the shortest path to not repeating our mistakes.
Want a team like ours?
72Technologies builds production software for the kind of teams who actually read this blog.
Start a projectKeep reading
Query Clustering with Embeddings: Building the Topic Map That Killed Our Cannibalization
Keyword cannibalization on a 12k-page site isn't a content problem — it's a clustering problem. Here's the embeddings pipeline we built to merge, redirect, and consolidate pages that were fighting each other in Google.
Hreflang at Scale: The Sitemap-Driven Approach That Survived 40 Locales
Inline hreflang tags break once you hit a dozen locales. Here's the sitemap-driven setup we use on programmatic sites with 40+ locales, including the validation pipeline that catches drift before Google does.
Content Decay Detection with GSC + GA4: The Refresh Queue That Actually Moves Rankings
Most 'content refresh' programmes are vibes. Here's the data pipeline we use to detect decaying URLs, score them by recoverable traffic, and feed a refresh queue writers actually ship against.
