Entity Salience

Originally published at thatdevpro.com. This framework reference is part of the 14-tier Engine Optimization stack from ThatDevPro, an SDVOSB-certified veteran-owned web + AI engineering studio. You are reading the dev.to mirror; the source-of-truth canonical version with embedded validation tools lives at the link above.

How Google's NLP Scores What a Page Is "About" — Entity Recognition, Prominence, and Topical Authority

A comprehensive installation and audit reference for understanding entity salience — the NLP-driven scoring system Google uses to determine what a page is fundamentally about — and structurally engineering pages so that the entities you want associated with the page are scored as highly salient. This document is dual-purpose: installation manual and audit document.

Cross-stack implementation note: the code samples in this framework are written in plain HTML for clarity. For React, Vue, Svelte, Next.js, Nuxt, SvelteKit, Astro, Hugo, 11ty, Remix, WordPress, Shopify, and Webflow equivalents of every pattern below, see framework-cross-stack-implementation.md. For pure client-rendered SPAs (no SSR/SSG) see framework-react.md. For Tailwind-specific concerns (purge, dynamic classes, dark-mode CLS, focus accessibility) see framework-tailwind.md.

1. Document Purpose & How to Use This Document

1.1 What This Document Is

This is the canonical reference for implementing entity salience optimization on a website. Entity salience is the natural language processing metric Google uses to determine which entities (people, places, organizations, topics, concepts) are central to a page versus merely mentioned. High salience for the entities you want associated with a page improves topical relevance, search rankings, and AI engine citation rates.

This framework specifies how to identify primary and supporting entities for a page, how to structurally place entities so NLP systems score them as highly salient, how to declare entity relationships through schema, and how to audit existing content for entity salience signals.

Entity salience is closely related to but distinct from Knowledge Graph optimization (framework-knowledgegraph.md). Knowledge Graph is about establishing the entity itself in Google's database. Entity salience is about how prominently that entity features on individual pages. A site can have a strong Knowledge Graph entity but weak per-page entity salience — meaning Google knows who you are but doesn't recognize that any specific page is "about" you.

1.2 Three Operating Modes

Mode A — Install Mode: Building entity salience optimization across the site. Follow Sections 2 → 14.

Mode B — Audit Mode: Evaluating how well existing pages signal entity salience. Skip to Section 11.

Mode C — Hybrid Mode: Audit then install for failing items.

1.3 How Claude Code CLI Should Consume This Document

1. Read Section 2 — collect client variables, especially primary entity definitions
2. Read Section 3 — understand entity salience and the NLP signals that drive it
3. Apply Section 4 — identify primary, supporting, and related entities per page
4. Install Sections 5-9 — structural patterns, schema, and content elements
5. Validate — Section 11 (use Google's Natural Language API to verify salience scoring)
6. Generate report — Section 14

1.4 Conflict Resolution Rules

1.5 Required Tools

• Google Cloud Natural Language API — cloud.google.com/natural-language — primary tool for testing entity salience scores on actual content
• Google Search Console — for understanding what queries pages rank for (signals what entities Google associates with the page)
• Schema.org validator — for verifying entity schema markup
• Google's Knowledge Graph Search API — for verifying entity recognition
• WordLift, InLinks, or similar — for entity-aware content management

2. Client Variables Intake

# ============================================
# ENTITY SALIENCE FRAMEWORK CLIENT VARIABLES
# ============================================

# --- Primary Entities (REQUIRED) ---
business_entity_name: ""             # The canonical name of the business as an entity
business_entity_type: ""             # Schema.org type
business_wikidata_qid: ""            # If exists
business_aliases: []                 # All ways the business is referenced

founder_entity_name: ""
founder_entity_type: "Person"
founder_wikidata_qid: ""
founder_aliases: []

# --- Topical Entities (REQUIRED) ---
primary_topical_entities: []         # The 3-7 topics this site is the authority on
                                     # Each topic is itself an entity
topical_entity_wikidata_qids: {}     # Map of topic name to Wikidata QID where applicable

# --- Per-Page Entity Mapping (REQUIRED for audit) ---
audited_pages:
  - url: ""
    intended_primary_entity: ""
    intended_supporting_entities: []
    actual_salience_scores: {}       # From Google NLP API testing
    salience_alignment: ""           # "aligned", "misaligned", "diluted"

# --- Entity Schema Status (REQUIRED) ---
has_organization_schema: false
has_person_schema_for_founder: false
has_topic_pages_with_thing_schema: false
schema_uses_at_id_for_entity_referencing: false  # Critical for entity graph

# --- Content Patterns (RECOMMENDED) ---
articles_use_primary_entity_in_h1: false
articles_open_with_primary_entity_definition: false
articles_use_consistent_entity_naming: false
articles_link_internally_with_entity_aware_anchors: false

# --- External Entity Signals (RECOMMENDED) ---
business_appears_in_knowledge_graph: false
founder_appears_in_knowledge_graph: false
topical_entity_pages_link_to_authoritative_external_sources: false

# --- Existing Entity Confusion (FILLED DURING AUDIT) ---
known_entity_disambiguation_issues: []  # E.g., business name shared with another entity
known_low_salience_pages: []
known_entity_drift_pages: []         # Pages that talk about something other than their stated topic

3. What Entity Salience Is

Entity salience is a numerical score (0.0 to 1.0) that represents how central a specific entity is to a piece of content. Google's Natural Language API exposes this score directly via its entity analysis endpoint — and the same scoring mechanism (or one substantially similar) operates within Google's ranking systems to determine what pages are "about."

When Google processes a page, its NLP system identifies all entities mentioned (people, places, organizations, products, concepts, etc.) and assigns each a salience score. The page is treated as being primarily "about" the highest-salience entity. Secondary entities are treated as supporting or related. Entities with very low salience are treated as tangential mentions.

Critical implication: a page can mention an entity without being recognized as "about" it. If the entity isn't given salience-driving prominence in the content structure, schema, and language patterns, the page won't rank for queries about that entity.

The signals that drive salience scoring include:

1. Position — Entities mentioned in the title, H1, opening paragraph, and URL get higher salience than entities mentioned later in the content.

2. Frequency — Entities mentioned more often (within reason) get higher salience. But frequency without position is weak.

3. Subject vs. object position — Entities that act as the grammatical subject get higher salience than entities in object position. "Joseph built the framework" makes Joseph more salient than "The framework, which was built by Joseph..."

4. Variety of mention — Entities referenced through multiple linguistic forms (proper noun, pronoun, definite article) get higher salience because the variety signals the entity is being discussed substantively.

5. Co-occurrence with related concepts — Entities mentioned alongside their typical related concepts get reinforced salience. A page about "diabetes" gets reinforced when it also mentions "blood sugar," "insulin," "A1C," etc. The co-occurrence pattern matches what's expected for that entity.

6. Schema declaration — Pages that explicitly declare a primary entity through schema (mainEntity, about) get clear salience signal regardless of NLP analysis.

7. Internal linking patterns — Pages that other pages link to with entity-aware anchor text get reinforced salience for that entity.

8. External signals — Pages cited by other authoritative sources for an entity get reinforced salience.

In 2026, entity salience operates at multiple layers:

Standard ranking — Used to determine topical relevance for search queries. Pages with high salience for query-related entities rank higher.

AI Overview source selection — When AI Overviews choose sources, entity salience helps determine which page is genuinely about the topic vs. which page just mentions it.

Topical authority compounding — Sites that maintain high entity salience across many pages on the same topical pillar build cumulative topical authority that's hard for competitors to dislodge.

Entity disambiguation — When multiple entities share a name (common business names, common personal names), salience signals help Google determine which entity is meant.

The entity salience framework, paired with Knowledge Graph optimization (framework-knowledgegraph.md), is foundational to modern SEO. Sites that don't engineer for entity salience underperform regardless of how strong other signals are.

4. Identifying Per-Page Entities

For every page, identify three categories of entities.

4.1 The Primary Entity

The single entity the page is fundamentally about. Most pages should have one primary entity:

• About page: the business or founder
• Author page: the author (Person entity)
• Service page: the service offering
• Product page: the product
• Article page: the topic of the article
• Local landing page: the location-specific business entity
• Glossary page: the term being defined
• Topic hub page: the topic itself

Pages with no clear primary entity are diluted and underperform. If you can't articulate the primary entity, restructure or remove the page.

4.2 Supporting Entities

Secondary entities that are tightly related to the primary entity and reinforce its meaning:

• For a service page: the audience the service serves, the outcomes the service produces, the methodology used
• For an article on diabetes: insulin, blood glucose, A1C, related conditions
• For an author page: their credentials, their employer (the business), topics they cover
• For a product page: the brand, the category, complementary products

Supporting entities should be present and given moderate salience. Their presence reinforces the primary entity's salience by establishing topical context.

4.3 Tangential Entities

Entities mentioned in passing but not central to the page. These should have low salience.

If tangential entities are getting unintended high salience, the page structure is diluting the primary entity. Common cause: long author bio sections on every article, lengthy related-article sections, off-topic conclusions.

4.4 Entity Mapping per Page

For every important page, document:

url: "/services/web-development/"
primary_entity:
  name: "Web Development"
  type: "Service"
  schema_id: "https://thatdeveloperguy.com/services/web-development/#service"

supporting_entities:
  - name: "ThatDeveloperGuy"
    type: "Organization"
    relationship: "provider"
  - name: "Joseph Anady"
    type: "Person"
    relationship: "founder/practitioner"
  - name: "Custom Website"
    type: "Product/Outcome"
    relationship: "deliverable"
  - name: "Small Business"
    type: "AudienceType"
    relationship: "audience"

tangential_entities:
  - name: "SEO"               # Mentioned but not primary
  - name: "Cassville Missouri" # Location context

This mapping informs structural decisions about each page.

5. Per-Page Entity Salience Implementation

How to engineer salience for the primary entity on each page.

5.1 Title and H1 Containing Primary Entity

The title and H1 must contain the primary entity name (or its closest natural language equivalent).

<title>{{PRIMARY_ENTITY_NAME}} | {{BUSINESS_NAME}}</title>
<h1>{{PRIMARY_ENTITY_NAME}}: {{DESCRIPTIVE_CONTEXT}}</h1>

Examples:

• Service page: <h1>Web Development for Small Business</h1> — primary entity "Web Development"
• Article: <h1>Diabetes Management: A Complete Guide for Patients</h1> — primary entity "Diabetes Management"
• About: <h1>About ThatDeveloperGuy</h1> — primary entity is the business

5.2 Opening Paragraph Establishing the Entity

The first paragraph of the page must establish the primary entity prominently. Typical pattern:

<p>{{PRIMARY_ENTITY_NAME}} is {{DEFINING_DESCRIPTION}}. {{PRIMARY_ENTITY_NAME}} {{ELABORATION_OR_KEY_FACT}}.</p>

Example for an article on entity salience itself:

<p>Entity salience is a numerical score that represents how central a specific entity is to a piece of content. Entity salience is calculated by Google's Natural Language Processing systems and used to determine what each web page is fundamentally about.</p>

Notice: the primary entity ("entity salience") appears twice in the opening — once as grammatical subject in defining sentence, once as subject again in elaborating sentence. This is the strongest possible signal.

5.3 URL Containing Primary Entity

The URL slug should reflect the primary entity:

• Good: /services/web-development/
• Good: /articles/entity-salience-guide/
• Good: /about/joseph-anady/
• Weak: /post/12345/ (no entity signal)
• Weak: /services/everything-we-do/ (no specific entity)

5.4 Body Content Subject Pattern

Throughout the body content, the primary entity should frequently be the grammatical subject:

Pattern (high salience):

• "Entity salience determines..." (entity as subject)
• "Entity salience operates by..."
• "When entity salience is calculated..."

Pattern (lower salience):

• "When you optimize for it, the system..." (entity replaced with pronoun, distant from subject)
• "It's a metric used by Google..." (entity referenced abstractly)

Vary linguistically to avoid keyword stuffing while maintaining subject-position salience.

5.5 Schema Declaring Primary Entity

Use mainEntity and about to explicitly declare the page's primary entity:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "@id": "{{PAGE_URL}}#article",
  "headline": "{{TITLE}}",
  "url": "{{PAGE_URL}}",

  "mainEntity": {
    "@type": "{{PRIMARY_ENTITY_TYPE}}",
    "@id": "{{PRIMARY_ENTITY_CANONICAL_URL}}#{{ENTITY_FRAGMENT}}",
    "name": "{{PRIMARY_ENTITY_NAME}}",
    "description": "{{ENTITY_DESCRIPTION}}",
    "sameAs": [
      "https://www.wikidata.org/wiki/{{ENTITY_QID}}",
      "{{OTHER_AUTHORITATIVE_REFERENCES}}"
    ]
  },

  "about": [
    {
      "@type": "Thing",
      "name": "{{PRIMARY_ENTITY_NAME}}",
      "sameAs": "https://www.wikidata.org/wiki/{{ENTITY_QID}}"
    }
  ],

  "mentions": [
    {
      "@type": "{{SUPPORTING_ENTITY_1_TYPE}}",
      "name": "{{SUPPORTING_ENTITY_1_NAME}}",
      "sameAs": "{{SUPPORTING_ENTITY_1_REFERENCE}}"
    },
    {
      "@type": "{{SUPPORTING_ENTITY_2_TYPE}}",
      "name": "{{SUPPORTING_ENTITY_2_NAME}}",
      "sameAs": "{{SUPPORTING_ENTITY_2_REFERENCE}}"
    }
  ]
}
</script>

The mainEntity declares the page is fundamentally about this entity. The about array can list additional core topics. The mentions array lists supporting entities — referenced but not primary.

5.6 Headings Reinforcing Primary Entity

H2 and H3 sections within the page should reinforce the primary entity through:

• Subheadings that include the entity or related concepts
• Topic structure that addresses dimensions of the entity
• Avoiding subheadings that pivot to off-topic content

Example heading structure for an article on entity salience:

<h1>Entity Salience: How Google Determines What a Page Is About</h1>
<h2>How Entity Salience Is Calculated</h2>
<h2>Why Entity Salience Matters for Rankings</h2>
<h2>How to Optimize Entity Salience on Your Pages</h2>
<h2>Entity Salience and Knowledge Graph: How They Connect</h2>
<h2>Common Entity Salience Mistakes</h2>

Every H2 stays on the primary entity. The page is unambiguously about entity salience.

5.7 Internal Links With Entity-Aware Anchor Text

Internal links to and from the page should use anchor text that reinforces entity meaning.

Strong anchor text:

• <a href="/articles/entity-salience-guide/">entity salience</a>
• <a href="/articles/entity-salience-guide/">how entity salience works</a>

Weak anchor text:

• <a href="/articles/entity-salience-guide/">click here</a>
• <a href="/articles/entity-salience-guide/">read this article</a>
• <a href="/articles/entity-salience-guide/">learn more</a>

When pages on a site consistently link to a primary entity page using entity-aware anchor text, the salience signal compounds.

5.8 Avoiding Salience Dilution

Common dilution patterns to avoid:

Long author bios on every article: A 200-word author bio at the bottom of every article gives the author entity high cumulative salience, potentially diluting the article's primary topical entity. Solution: shorter author boxes, link out to author page for detail.

Boilerplate "About the Company" footers: Long company descriptions in every page footer. Solution: minimal footer with link to About page.

Off-topic conclusions: Articles that pivot to selling services or unrelated topics in the closing paragraphs. Solution: end on the primary topic.

Unrelated related-content sections: Sidebars showing articles unrelated to current topic. Solution: related content actually related.

Excessive related entity mentions: Mentioning many entities for keyword variety can dilute primary entity salience. Solution: mention what's relevant; don't pad.

5.9 Entity Salience Testing

After implementing, test salience using Google's Natural Language API:

# Submit page text to Cloud Natural Language API
gcloud ml language analyze-entities --content-file=page-content.txt

Or via the web UI at cloud.google.com/natural-language/docs/quickstart-client-libraries.

The response shows each entity, its type, and its salience score (0.0-1.0). Verify:

• Primary entity has highest salience score (typically 0.4+ for well-optimized pages)
• Supporting entities have moderate salience (0.05-0.2)
• Tangential entities have low salience (<0.05)
• The intended primary entity actually has the top score

If the primary entity isn't the top-scored entity, restructure the page. Common fixes:

• Add primary entity to title and H1 if missing
• Lead with primary entity in opening paragraph
• Increase frequency of primary entity in subject position
• Reduce length of competing entity content (author bios, business descriptions, etc.)
• Add schema declaring primary entity

6. Site-Wide Entity Salience Implementation

Beyond per-page work, the site needs a coherent entity strategy.

6.1 Phase 1: Entity Map of the Site

Document the entities that organize the site:

# Site entity map

primary_business_entity:
  name: "ThatDeveloperGuy"
  type: "Organization"
  canonical_page: "/about/"
  schema_id: "https://thatdeveloperguy.com/#organization"
  wikidata: "Q138610626"

primary_person_entities:
  - name: "Joseph Anady"
    type: "Person"
    canonical_page: "/about/joseph-anady/"
    schema_id: "https://thatdeveloperguy.com/about/joseph-anady/#person"
    wikidata: "{{QID}}"

primary_topical_entities:
  - name: "Web Development"
    canonical_page: "/topics/web-development/"
    schema_id: "https://thatdeveloperguy.com/topics/web-development/#topic"
  - name: "SEO"
    canonical_page: "/topics/seo/"
    schema_id: "https://thatdeveloperguy.com/topics/seo/#topic"
  - name: "AI Optimization"
    canonical_page: "/topics/ai-optimization/"
    schema_id: "https://thatdeveloperguy.com/topics/ai-optimization/#topic"

primary_service_entities:
  - name: "Custom Website Development"
    canonical_page: "/services/web-development/"
  - name: "Engine Optimization"
    canonical_page: "/services/optimization/"

Each primary entity has a canonical page where it lives, a stable schema @id for graph references, and (where applicable) external entity references like Wikidata.

6.2 Phase 2: Topical Hub Pages With Thing Schema

Each primary topical entity gets a hub page demonstrating depth of coverage on that entity. See framework-eeat.md Section 4.2.3 for full topical hub structure. Add Thing schema to formalize the entity:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "CollectionPage",
  "@id": "https://{{PRIMARY_DOMAIN}}/topics/{{TOPIC_SLUG}}/#collectionpage",
  "url": "https://{{PRIMARY_DOMAIN}}/topics/{{TOPIC_SLUG}}/",
  "name": "{{TOPIC_NAME}}",
  "mainEntity": {
    "@type": "Thing",
    "@id": "https://{{PRIMARY_DOMAIN}}/topics/{{TOPIC_SLUG}}/#topic",
    "name": "{{TOPIC_NAME}}",
    "description": "{{TOPIC_DESCRIPTION}}",
    "sameAs": [
      "https://www.wikidata.org/wiki/{{TOPIC_QID}}",
      "https://en.wikipedia.org/wiki/{{TOPIC_WIKIPEDIA_SLUG}}"
    ]
  },
  "publisher": {"@id": "https://{{PRIMARY_DOMAIN}}/#organization"},
  "author": {"@id": "https://{{PRIMARY_DOMAIN}}/authors/{{AUTHOR_SLUG}}/#person"}
}
</script>

Topical hub pages with strong Thing schema and substantive content become the canonical reference for the topic on the site.

6.3 Phase 3: Internal Linking Around Entity Hubs

Every article on a topic should link back to the topical hub page using entity-aware anchor text:

<p>For more on {{TOPIC_NAME}}, see our <a href="/topics/{{TOPIC_SLUG}}/">{{TOPIC_NAME}} hub</a>.</p>

The hub page should link out to all articles on the topic, organized hierarchically. This creates a hub-and-spoke link pattern that reinforces the hub as the topical entity authority.

6.4 Phase 4: Schema Graph With Cross-References

Build a coherent schema graph using @id references so entities link explicitly:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://{{PRIMARY_DOMAIN}}/#organization",
      "name": "{{BUSINESS_NAME}}",
      "founder": {"@id": "https://{{PRIMARY_DOMAIN}}/about/{{FOUNDER_SLUG}}/#person"}
    },
    {
      "@type": "Person",
      "@id": "https://{{PRIMARY_DOMAIN}}/about/{{FOUNDER_SLUG}}/#person",
      "name": "{{FOUNDER_NAME}}",
      "worksFor": {"@id": "https://{{PRIMARY_DOMAIN}}/#organization"},
      "knowsAbout": [
        {"@id": "https://{{PRIMARY_DOMAIN}}/topics/web-development/#topic"},
        {"@id": "https://{{PRIMARY_DOMAIN}}/topics/seo/#topic"}
      ]
    },
    {
      "@type": "Thing",
      "@id": "https://{{PRIMARY_DOMAIN}}/topics/web-development/#topic",
      "name": "Web Development"
    }
  ]
}
</script>

The cross-references via @id create a graph Google can navigate. This is especially important for sites with many topical entities and multiple authors — the graph clarifies who-knows-what.

6.5 Phase 5: Author-Topic Affinity

Authors should be connected to specific topical entities through knowsAbout:

<script type="application/ld+json">
{
  "@type": "Person",
  "@id": "https://{{PRIMARY_DOMAIN}}/authors/{{AUTHOR_SLUG}}/#person",
  "name": "{{AUTHOR_NAME}}",
  "knowsAbout": [
    "Web Development",
    "Search Engine Optimization",
    "AI Search Optimization"
  ]
}
</script>

This declares topical authority for the author and reinforces the connection between the author entity and the topical entities.

6.6 Phase 6: Cross-Site Entity Reinforcement

Use external entity references to reinforce site entities:

• Wikidata entry for business and founder
• Wikipedia entry if notability supports it
• LinkedIn company and personal profiles
• Industry directory listings
• Wikidata entries for topical entities (most major topics already have QIDs)

External references via sameAs strengthen Google's confidence in the entity. See framework-knowledgegraph.md for full Knowledge Graph implementation.

7. Entity Disambiguation

When entities share names (common business names, common personal names, common topic terms), disambiguation becomes critical.

7.1 Disambiguation Through Specificity

Add specificity to entity references:

• Not "Joseph Anady" alone, but "Joseph Anady, founder of ThatDeveloperGuy"
• Not "Web Development" alone, but "Web Development for Small Business"
• Not "ThatDeveloperGuy" alone, but "ThatDeveloperGuy, the SDVOSB-certified web development firm based in Cassville, Missouri"

Specificity in early mentions establishes which entity is meant.

7.2 Disambiguation Through Schema

Use schema @id and sameAs to point unambiguously to the correct entity:

{
  "@type": "Person",
  "@id": "https://thatdeveloperguy.com/about/joseph-anady/#person",
  "name": "Joseph Anady",
  "alternateName": "Joseph W. Anady",
  "sameAs": [
    "https://www.wikidata.org/wiki/{{QID}}",
    "https://www.linkedin.com/in/joseph-anady-XXX/",
    "https://huggingface.co/Janady07"
  ]
}

The unique combination of name + sameAs links + Wikidata QID disambiguates from any other Joseph Anady.

7.3 Disambiguation Through Co-occurrence Pattern

When the entity is mentioned, surround with co-occurring entities that disambiguate:

For Joseph Anady (this site): mentioned alongside ThatDeveloperGuy, Cassville Missouri, web development, SDVOSB, etc.

For some other Joseph Anady (a different person): would be mentioned alongside their context.

The co-occurrence pattern is a strong disambiguation signal.

7.4 Disambiguation Through Internal Linking

Always link entity mentions to the entity's canonical page on first occurrence in significant content:

<p>This framework was developed by <a href="/about/joseph-anady/">Joseph Anady</a>, founder of <a href="/">ThatDeveloperGuy</a>, based on <a href="/about/joseph-anady/#experience">12 years of experience</a> implementing it on client sites.</p>

The link makes clear which entity is referenced.

8. Common Mistakes & Anti-Patterns

8.1 No Clear Primary Entity

Anti-pattern: Pages that try to cover many topics equally with no clear primary focus.

Why it fails: Salience is diluted across multiple entities; none reaches strong salience. Page doesn't rank well for any topic.

Fix: Pick one primary entity per page. If the content needs to cover multiple, split into separate pages.

8.2 Primary Entity Not in Title/H1

Anti-pattern: Title and H1 use clever framing that doesn't include the primary entity name.

Why it fails: Position-based salience is the strongest signal. Missing it weakens everything else.

Fix: Primary entity name in title and H1 always.

8.3 Long Author Bio Everywhere

Anti-pattern: 300-word author bio appearing at the bottom of every article.

Why it fails: Author entity gets high cumulative salience across the site, potentially competing with topical entities.

Fix: Short author box (50-100 words) linking to full author page where bio lives.

8.4 Generic Anchor Text

Anti-pattern: Internal links using "click here," "read more," "learn more" instead of entity-aware text.

Why it fails: Loses the link-based salience reinforcement opportunity.

Fix: Entity-aware anchor text on internal links.

8.5 Schema Misalignment

Anti-pattern: Schema declares one entity as mainEntity while content emphasizes another.

Why it fails: Mixed signals confuse Google's interpretation. Either the schema or content is wrong.

Fix: Align schema and content. Pick one primary entity, declare it in schema, structure content to match.

8.6 Topical Drift

Anti-pattern: Articles whose body content drifts from the stated topic. Title says X, content covers X for two paragraphs then pivots to Y.

Why it fails: NLP detects the drift. Salience signal weakens.

Fix: Stay on topic throughout. If two topics need coverage, split into two articles.

8.7 Missing sameAs

Anti-pattern: Schema declares an entity but doesn't link to external entity references.

Why it fails: Loses the cross-source reinforcement that disambiguates and strengthens entity recognition.

Fix: sameAs array with all authoritative external references for each declared entity.

8.8 Over-Mentioning Primary Entity

Anti-pattern: Trying to manipulate salience by repeating the entity name unnaturally often.

Why it fails: Reads as keyword-stuffed. NLP detects unnatural patterns. Quality suffers.

Fix: Natural prose with primary entity in subject position frequently. Use pronouns and varied references for readability while maintaining subject-position pattern.

8.9 No Topical Hub Pages

Anti-pattern: Articles on topics published without a hub page connecting them.

Why it fails: No central authority for the topic. Each article competes individually rather than reinforcing a topical authority.

Fix: Build topical hub for each primary pillar.

8.10 Inconsistent Entity Naming

Anti-pattern: Same entity referenced inconsistently — "ThatDeveloperGuy" vs "That Developer Guy" vs "Joseph's company" vs "the agency" — across pages.

Why it fails: Diluted salience for the canonical entity name.

Fix: Pick canonical name and use consistently. Use alternateName in schema for legitimate variations.

9. Stack-Specific Notes

9.1 WordPress

• Use Yoast or Rank Math to manage primary keyword/entity per article
• ACF or similar for entity metadata: primary entity, supporting entities, sameAs references
• WordLift plugin specifically designed for entity-aware content
• Custom queries to surface internal linking opportunities for topical hubs

9.2 Next.js / Astro / Hugo

• TypeScript schema for content frontmatter requiring primaryEntity field
• Schema generators that automatically create mainEntity and about from frontmatter
• Build-time entity validation
• Internal linking suggestions based on entity tags

9.3 Universal Pattern

• Maintain entity registry (which entities exist, where they live, what their canonical references are)
• Per-page entity assignment as part of content workflow
• Schema generators that use entity registry for @id references
• Link suggestions that recommend entity-aware anchor text

10. Cross-Reference to the 14-Tier Framework

Entity Salience implementation touches:

• Tier 1 SDO — Structured Data Optimization implements core entity schema
• Tier 1 EEA — E-E-A-T Entity Optimization with Person/Organization schema
• Tier 3 EEO — Entity Engine Optimization explicitly addresses entity salience
• Tier 3 KGO — Knowledge Graph Optimization establishes the entities themselves
• Tier 3 SGA — SearchGPT Optimization rewards strong entity salience
• Tier 4 ITO — Industry Topic Optimization aligns with topical hub work
• Tier 4 PBO — Personal Brand Optimization for the founder Person entity

11. Audit Mode

11.1 Per-Page Audit

For sample pages, score:

Per-page score: 10. World-class entity salience: 9+/10.

11.2 Site-Wide Audit

Site score: 10.

12. Maintenance Schedule

12.1 Monthly

• Test 5 random pages in Google NLP API; verify primary entity has highest salience
• Review newly published articles for entity markers
• Check for entity drift in older content

12.2 Quarterly

• Site-wide entity salience audit
• Update topical hub pages with new content
• Review entity map for changes (new topics, new authors)
• Refresh sameAs references

12.3 Annually

• Comprehensive site entity strategy review
• Update Wikidata entries with significant changes
• Audit for new disambiguation issues
• Review entity registry against actual published content

13. Implementation/Audit Report Templates

13.1 Implementation Report Template

# Entity Salience Framework Implementation Report

**Site**: {{BUSINESS_NAME}}
**Implementation Date**: {{TODAY}}

## Site Entity Map Established
{{LIST_OF_PRIMARY_ENTITIES}}

## Topical Hub Pages Created
{{LIST}}

## Schema Graph Cross-References Implemented
{{COUNT_OF_AT_ID_REFERENCES}}

## Pages Restructured for Salience
{{COUNT}}

## Average Salience Score Improvement
{{BEFORE}} → {{AFTER}}

## NLP API Validation Results
{{TABLE_OF_PAGES_AND_SCORES}}

## Sign-Off

13.2 Audit Report Template

# Entity Salience Audit Report

**Site**: {{BUSINESS_NAME}}
**Audit Date**: {{TODAY}}

## Per-Page Findings (Sample)
{{TABLE_WITH_NLP_API_SCORES}}

## Site-Wide Findings
{{LIST_WITH_SCORES}}

## Entity Salience Distribution
- Pages with primary entity highest salience: {{PERCENTAGE}}%
- Pages with competing salience: {{PERCENTAGE}}%
- Pages with diluted salience: {{PERCENTAGE}}%

## Critical Findings
{{LIST}}

## Remediation Plan
{{PRIORITIZED_LIST}}

## Sign-Off

End of Framework Document

Document version: 1.0
Last updated: 2026-04-29
Maintained by: ThatDeveloperGuy

Entity salience is the layer between content and ranking that determines whether your content ranks for the queries it should. Without strong entity salience, even excellent content underperforms. The good news: entity salience is largely a structural problem, solvable through deliberate content and schema engineering. Sites that systematically engineer for entity salience build cumulative topical authority that's difficult for competitors to replicate.

Companion documents:

• framework-eeat.md
• framework-ymyl.md
• framework-hcs.md
• framework-sqrg.md
• framework-coreupdates.md
• framework-infogain.md
• framework-knowledgegraph.md
• framework-aicitations.md

From the ThatDevPro Engine Optimization framework library. Studio: ThatDevPro (SDVOSB veteran-owned web + AI engineering). Sister property: ThatDeveloperGuy. Source: https://www.thatdevpro.com/insights/framework-entitysalience/.