Originally published at thatdevpro.com. This article 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 republish; the canonical source is on ThatDevPro.com. Source repo for the AI-citation surfaces: github.com/Janady13/aio-surfaces.

Tier Explanation: Dominate generative AI engines and LLMs by making every page citation-friendly, machine-readable, and entity-strong. As of 2026, AI search demands extractability, original data, verifiable claims, freshness signals, multimodal pairing, and clear provenance so engines like ChatGPT, Perplexity, Claude, Gemini, Copilot, and Grok cite you accurately. All actions execute on website pages, templates, schema, dynamic feeds, and supporting infrastructure. Tiers 1 and 2 must be in place first.

Related Frameworks

This tier implements the following framework documents in the /Framework/ library. Consult them for canonical reference, audit rubrics, and detailed implementation patterns.

• framework-aicitations.md — ChatGPT, Perplexity, Claude, Gemini, Copilot citation mechanics
• framework-knowledgegraph.md — Wikidata, Wikipedia, Knowledge Panel, sameAs network
• framework-entitysalience.md — Per-page entity engineering, NLP salience scoring
• framework-schema.md — Structured data underpinning AI extraction
• framework-multimodalsearch.md — Multimodal queries combining text/image/voice/video
• framework-agenticaisearch.md — Agentic AI search and autonomous task execution
• framework-infogain.md — Original value AI engines weight when citing

A. AI Answer & Extraction (5)

1. AEO — Answer Engine Optimization

• Place complete standalone answer in the first 80–100 words (TL;DR style above the fold)
• Use short paragraphs (3–4 sentences max), bold key claims, numbered lists, and comparison tables
• Add “Key Takeaways” or “Quick Answer” box at top of every high-intent page
• Include author name, last-updated date, and inline citations for every statistic or claim
• Format answers to match question structure: “What is X?” → “X is [direct definition]”
• Write self-contained 40–60 word answer paragraphs that work as extracted snippets
• Add Question and Answer schema where genuinely applicable
• Validation: Test target queries in ChatGPT, Perplexity, and Gemini — page appears in citation list within 30 days

2. GEO — Generative Engine Optimization

• Lead with unique statistics, original research, or comparison data in first 300 words
• Use authoritative, fluent language optimized for LLM summarization (avoid hedging like “might” or “could”)
• Add “Expert Perspective” or “From Our Research” subsections with credentialed authors
• Maintain high factual density — every paragraph should contain at least one citable fact
• Use third-person factual statements (“X has been shown to…”) that LLMs can directly quote
• Include “Why It Matters” framing that explains stakes and context
• Pair every key claim with a verifiable source link
• Validation: Page cited as source in AI engine answers, original data points get quoted verbatim

3. CAO — Conversational AI Optimization

• Write in natural Q&A format with H2s phrased as actual questions users would ask
• Create dedicated follow-up question sections at the bottom of each topic
• Use conversational H2s (“What is X?”, “How do I Y?”, “Why does Z happen?”)
• Match exact phrasing from voice search queries and chatbot prompts
• Write in second person with direct, helpful tone
• Add “Related questions” section that mirrors PAA structure from Google
• Include conversation starter prompts users could paste into ChatGPT to find your page
• Validation: Page surfaces as source for follow-up questions in conversational AI sessions

4. RCO — RAG Chunk Optimization

• Structure content into self-contained chunks of 200–400 words that make sense in isolation
• Each chunk leads with a topic sentence summarizing the entire section
• Add semantic chunk boundaries via <section> and <article> tags with id attributes for direct linking
• Avoid mid-paragraph references to other sections (“as mentioned above”) — chunks must stand alone
• Include enough context per chunk that a retrieval system can return it as a complete answer
• Use descriptive H2/H3 headings that act as chunk titles (RAG systems use heading hierarchy for relevance scoring)
• Test chunk extraction by copying any single section and asking if it makes sense without surrounding context
• Validation: Each section returns standalone meaningful content when extracted, retrieval tools return relevant chunks for target queries

5. PRO — Prompt Response Optimization

• Identify common prompt patterns users send to ChatGPT, Claude, and Perplexity in your niche
• Build dedicated answer pages for each prompt pattern (e.g., “best X for Y under $Z”)
• Match content structure to expected AI response format: comparison tables, ranked lists, pros and cons
• Anticipate follow-up prompts and pre-answer them on the same page
• Use prompt-style headings: “Compare X vs Y”, “How to choose between A and B”, “Best X for [use case]”
• Include “If you’re using AI to research this, here’s what to ask” section to prime user prompts toward your content
• Test target prompts weekly across major AI engines to verify your content appears in citation
• Validation: Top 20 prompt patterns in your niche return your content as primary citation

B. Entity & Knowledge Graph (4)

6. EEO — Entity Engine Optimization

• Add consistent Organization and Person schema on every page with stable @id URIs
• Build a central entity hub at /entity/ or /about/ with full markup describing your organization
• Link to authoritative external entity sources via sameAs (Wikidata, Crunchbase, LinkedIn, GitHub)
• Use exact entity name consistently across all pages — no variations or abbreviations
• Cross-reference entities across schemas (Organization → founder Person → published Articles)
• Add additionalType to specify subtype precisely (e.g., LocalBusiness → ProfessionalService → WebDesignAgency)
• Maintain entity attributes: founding date, founders, products, services, awards, publications, areas served
• Validation: Google’s Knowledge Graph API recognizes entity, schema validates with cross-page links intact

7. KGO — Knowledge Graph Optimization

• Submit complete Organization + sameAs array in JSON-LD on homepage and About page
• Build relationships with related entities via schema parentOrganization, subOrganization, memberOf
• Claim and complete Google Knowledge Panel via Google Search Console verification
• Build out entity attributes: founding date, founders, awards, headquarters, areas served
• Cross-link to Wikidata Q-ID via sameAs so Google connects your entity to its knowledge graph
• Monitor Knowledge Panel for inaccuracies and submit corrections via Google’s panel feedback
• Add Person knowledge graph for founders and key personnel with full sameAs network
• Validation: Knowledge Panel appears for brand search, all attributes accurate, Wikidata linked

8. BLF — Brand Language Feed Optimization

• Create public JSON file at /brand-language-feed.json with official brand facts
• Include: brand name, alternate names, values, product specs, positioning, key messaging, founding details
• Add lastUpdated timestamp and version field for AI freshness validation
• Reference feed from robots.txt and llms.txt so AI crawlers discover it
• Update quarterly via CMS export script — automate via webhook on brand asset changes
• Mirror feed contents in human-readable /brand/ page for both AI and user consumption
• Provide downloadable formats: JSON, YAML, plain markdown for different AI consumption styles
• Validation: Feed file returns 200, validates as JSON, AI engines surface accurate brand attributes when queried

9. WIK — Wikipedia & Wikidata Optimization

• Build out Wikidata entry first — lower notability bar than Wikipedia, foundational for AI training data
• Add structured Wikidata properties: instance of, founded by, founding date, headquarters, official website, industry
• Reference Wikidata Q-ID across all Person and Organization schema via sameAs
• For Wikipedia: build neutral, well-sourced article via experienced editor — never self-edit your own entry
• Maintain consistent facts between Wikidata, Wikipedia, your site, and other authoritative sources
• Link Wikidata entry to LinkedIn, Crunchbase, GitHub, and other authority profiles
• Monitor for vandalism or inaccuracies on Wikipedia and Wikidata pages quarterly
• Validation: Q-ID resolves and references your domain, Wikipedia article (if applicable) is stable and accurate, AI engines pull correct attributes

C. Multimodal & Structured Data (3)

10. MMO — Multimodal Optimization

• Pair every key content section with relevant image, video, or diagram
• Add descriptive alt text, captions, and ImageObject / VideoObject schema with full metadata
• Optimize images for Google Lens and Gemini multimodal recognition (clear subject, good lighting, distinct framing)
• Include VideoObject with transcript, thumbnailUrl, uploadDate, duration, embedUrl, contentUrl
• Add transcripts and chapter markers for all videos to make them indexable and quotable
• Use AudioObject schema for podcasts with full transcript embedded in page
• Cross-reference media across schema (Article → image → ImageObject with caption matching content)
• Validation: Images surface in Google Lens results, video appears in YouTube and Google video search, transcripts indexed

11. AFO — AI Function Optimization

• Add structured function descriptions in JSON-LD for tools, calculators, and processes
• Use HowTo schema for procedural content with full step-by-step HowToStep markup
• Include “How to Use This” section with clear inputs, outputs, and expected results
• Document parameters, prerequisites, and edge cases that AI agents need to invoke functions
• Add SoftwareApplication schema for tools with applicationCategory and operatingSystem
• Build agent-friendly descriptions: when to use this tool, when not to, what it returns
• Document API endpoints in OpenAPI spec if you offer one — AI agents may call them directly
• Validation: Tool or function appears in AI assistant responses when users ask procedural questions

12. VEO — Vector Embedding Optimization

• Structure content so semantically related concepts cluster naturally in embedding space
• Use consistent terminology within a topic — don’t mix synonyms in the same section
• Define key terms once, then use them consistently throughout the page
• Group related content into clearly bounded sections so vector similarity matches are clean
• Avoid topical drift within a page — each page should map to one tight embedding region
• Use OpenAI or Cohere embedding APIs to test page similarity to target queries before publishing
• Maintain semantic distinctness between competing pages on your site to avoid embedding overlap
• Validation: Cosine similarity between page and target query above 0.7, sister pages clearly distinct in embedding space

D. Crawler Access & Platform (3)

13. ACM — AI Crawler Access Management

• Decide allow/disallow strategy per AI bot — default to ALLOW for citation visibility unless content is sensitive
• Add explicit rules for: GPTBot, ClaudeBot, Claude-Web, PerplexityBot, Google-Extended, OAI-SearchBot, anthropic-ai, ChatGPT-User, Applebot-Extended
• Configure separate rules for training crawlers vs answer crawlers (e.g., disallow GPTBot training, allow OAI-SearchBot for answer surfacing)
• Monitor server logs for AI bot traffic to confirm rules are respected and identify rogue bots
• Block bad-actor scrapers that mimic AI bots via user-agent verification at WAF level
• Add Cloudflare AI Audit or equivalent edge rules for granular bot control
• Maintain bot allowlist documentation for client transparency and audit trail
• Validation: Server logs show expected AI bot traffic patterns, robots.txt directives respected by major bots

14. PSO — Platform-Specific Optimization

• ChatGPT (OpenAI): Direct answers, structured data, clear authority signals; ensure OAI-SearchBot is allowed
• Perplexity: Citation-rich content with diverse, recent sources; ensure PerplexityBot is allowed
• Claude (Anthropic): Nuanced, well-reasoned content with clear caveats and sourcing; ensure ClaudeBot is allowed
• Gemini (Google): Strong E-E-A-T signals, Google ecosystem alignment, claimed Knowledge Panel
• Copilot (Microsoft): Bing visibility prerequisite, IndexNow integration per Tier 1 INO, Bing Webmaster Tools active
• Grok (xAI): Real-time relevance, X/Twitter brand presence, current event tie-ins, recent publication dates
• Test priority queries weekly across all platforms, document where you appear and where you don’t
• Maintain platform-specific test query log with citation appearance tracking by date and platform
• Validation: Page appears as cited source in at least 4 of 6 major AI platforms for primary queries

15. CTM — Citation Tracking & Monitoring

• Set up daily citation tracking via tools like Profound, Otterly, AthenaHQ, or Rankability
• Track citation rate per AI engine: ChatGPT, Perplexity, Claude, Gemini, Copilot, Grok
• Monitor share of voice — what percentage of relevant queries cite your site versus competitors
• Track citation accuracy — does the AI quote you correctly or paraphrase you incorrectly?
• Document citation trend lines per page and per topic cluster monthly
• Build feedback loop: pages that aren’t getting cited get audited, re-optimized, and re-tested
• Set monthly KPI targets per engine: citation count, share of voice, accuracy rate
• Validation: AI citation dashboard maintained, monthly trend report shows growing citation rate across engines

E. Scale & Dynamic Content (2)

16. PGO — Programmatic Growth Optimization

• Build template-driven page system for scalable answer pages with built-in originality checks
• Auto-generate unique meta titles, descriptions, and schema per programmatic page
• Inject location, product, or attribute variables into deterministic content templates
• Add E-E-A-T elements per template: author byline, last-updated date, citations, trust signals
• Validate every generated page passes thin-content checks before publishing (minimum word count, originality threshold)
• Implement deduplication logic to prevent near-duplicate pages from indexing
• Monitor programmatic page indexation in GSC weekly — high deindexation rate signals templates are too thin
• Validation: 100% of programmatic pages indexed, average time on page above 30 seconds, no thin-content flags

17. DCO — Dynamic Content Optimization

• Use edge or server-side rendering to personalize content based on referrer, geo, or device
• Create modular, parseable content blocks that AI engines can extract independently
• Add <noscript> fallbacks for any JS-rendered content to ensure AI bots see static version
• Use SSR plus hydration model so initial HTML contains full content for crawlers
• Test dynamic variants with Googlebot and GPTBot user-agents to confirm consistency
• Implement A/B testing with proper rel="canonical" handling so AI doesn’t see split content as duplicates
• Avoid client-side-only personalization for SEO-critical content blocks
• Validation: View Source shows full content, GSC URL Inspection rendered HTML matches View Source, AI bot user-agent tests succeed

F. Trust & Verification (3)

18. VCO — Verifiable Claims Optimization

• Every factual claim must have a clickable source link or inline citation
• Use Claim and ClaimReview schema for fact-check-eligible content
• Add citation property to Article schema listing primary sources
• Maintain a sources/references section at bottom of every long-form article
• Cite primary sources (research papers, government data, official documentation) over secondary aggregators
• Date-stamp every claim — “as of [date]” for time-sensitive facts
• Add author byline with credentials for every claim-heavy article
• Build trust by providing data files (CSV, JSON) for proprietary research findings
• Validation: Every long-form article has 5+ verifiable citations, ClaimReview validates where applicable, no orphan claims

19. ASM — AI Sentiment Monitoring

• Run brand queries across AI engines monthly: “What is [brand]?”, “Is [brand] reliable?”, “Best [brand] alternatives”
• Document AI-generated brand descriptions, ratings, and sentiment per platform
• Identify outdated or incorrect AI claims about your brand and prioritize correction
• Counter inaccurate AI claims by publishing corrective authoritative content on owned domain
• Update Wikipedia and Wikidata when AI engines pull from outdated entries
• Track AI sentiment drift over time — note when descriptions change favorably or unfavorably
• Use AI audit tools (Profound, AthenaHQ, Otterly) to automate sentiment tracking
• Validation: Monthly AI sentiment report maintained, no major inaccuracies persist past 30 days

20. FRO — Freshness & Recency Optimization

• Update dateModified in Article schema on every meaningful refresh (not minor typo fixes)
• Add visible “Last updated: [date]” banner at top of every article
• Include current year in titles where relevant (“Best X in 2026”)
• Refresh statistics, pricing, and time-sensitive claims quarterly
• Rebuild stale pages over 12 months old that target competitive keywords
• Set up Google Alerts on key topics to surface refresh-worthy news
• Build editorial calendar with refresh slots, not just new content slots
• Add datePublished AND dateModified so AI engines can weight recency appropriately
• Validation: Average article age under 18 months, freshness score (Inlinks or equivalent) above 80, AI engines cite recent content over stale

Summary

• Total items: 20
• Sub-clusters: 6 (AI Answer & Extraction, Entity & Knowledge Graph, Multimodal & Structured Data, Crawler Access & Platform, Scale & Dynamic Content, Trust & Verification)
• Format: Each item includes 6–8 implementation steps plus a validation criterion
• Net change from original: 7 consolidated, 7 added, 6 platform items merged into 1, 1 renamed
• Position in stack: AI tier — depends on Tiers 1 and 2, feeds into Tier 4 (Entity & Authority) and beyond

About this series

This is one of 14 articles in ThatDevPro’s Engine Optimization stack — a productized SEO + AEO + AIO + GEO service. Each tier is a self-contained framework with concrete checklists, validation steps, and code patterns.

Canonical source for this article: https://www.thatdevpro.com/insights/seo-tier-3-ai-domination/

The 14-tier series:

1. Tier 1 — Foundation
2. Tier 2 — Search Visibility
3. Tier 3 — AI Domination
4. Tier 4 — Entity and Authority
5. Tier 5 — Local Domination
6. Tier 6 — Content and Multimedia
7. Tier 7 — Social and Community
8. Tier 8 — Data, Analytics, Conversion
9. Tier 9 — Monitoring and Intelligence
10. Tier 10 — Workflow and Operations
11. Tier 11 — Marketplace and Retail
12. Tier 12 — International
13. Tier 14 — Advanced and Immersive

Tier 13 is retired.

Need this implemented on your site? ThatDevPro ships the full 14-tier stack as a productized service. SDVOSB-certified veteran-owned. Cassville, Missouri. See the Engine Optimization service.

Open-source tooling powering this series:

• aio-surfaces — Python toolkit (MIT) for generating llms.txt + aeo.json + entity.json + brand.json
• llms.txt generator — live Hugging Face Space

Originally published at thatdevpro.com. This article 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 republish; the canonical source is on ThatDevPro.com. Source repo for the AI-citation surfaces: github.com/Janady13/aio-surfaces.

Tier Explanation: Controls traditional search rankings through content strategy, topical authority, SERP feature targeting, trust signals, and ethical link work. All actions execute on your website pages, templates, CMS, and supporting infrastructure. Tier 1 must be complete first.

Related Frameworks

This tier implements the following framework documents in the /Framework/ library. Consult them for canonical reference, audit rubrics, and detailed implementation patterns.

• framework-keywordresearch.md — Query discovery, intent classification, mapping, cannibalization
• framework-hcs.md — Helpful Content System — Who/How/Why patterns
• framework-infogain.md — Information Gain — original value over the SERP corpus
• framework-eeat.md — E-E-A-T quality framework
• framework-featuredsnippets.md — Position zero, AI Overviews, PAA, SERP features
• framework-linkbuilding.md — Earned backlinks, outreach
• framework-trustsignals.md — Trust beyond E-E-A-T — badges, certifications, social proof
• framework-internallinking.md — Topical clusters, anchor text discipline

A. Content Strategy & Research (5)

1. SIM — Search Intent Mapping

• Classify every target keyword by intent type: informational, navigational, commercial, transactional
• Map content type to intent: informational → guide/blog, commercial → comparison/listicle, transactional → product/service page, navigational → branded landing
• Run target keyword in Google, screenshot top 10 SERP, identify dominant content format and match it
• Flag mismatched pages in audit (e.g., service page targeting informational query) for rebuild or repurpose
• Add intent tag as custom field in CMS for every page so future updates respect intent
• Re-evaluate intent quarterly — Google’s interpretation shifts as user behavior evolves
• Validation: SERP analysis matrix shows target page format aligns with top 3 ranking results for each priority keyword

2. CGA — Content Gap Analysis

• Run Ahrefs/Semrush Content Gap report against top 3 competitors to identify keywords they rank for that you don’t
• Identify topical gaps in your hub structure where competitor coverage is deeper
• Build a prioritization matrix: search volume × keyword difficulty × business relevance
• Create a content calendar covering top 20 gap keywords over the next 90 days
• Track gap closure monthly — measure new ranking keywords gained vs competitor delta
• Identify competitor-only featured snippets you could win with better-formatted answers
• Validation: Gap report shows month-over-month reduction in competitor-only keywords, your visibility share increases

3. CMA — Competitor Mapping & Analysis

• Identify top 5 SERP competitors per priority keyword cluster (not just business competitors — SERP competitors)
• Document each competitor’s content depth, schema usage, internal link patterns, backlink profile, and content cadence
• Reverse-engineer top-ranking pages: word count, heading structure, media types, schema, freshness signals
• Track competitor publishing velocity and topical expansion using Visualping or similar change-monitoring tools
• Build “what we have to beat” target spec for every priority page based on competitor benchmarks
• Update competitor map quarterly — SERP competitors change as new players enter
• Validation: Competitor matrix spreadsheet maintained, every priority page has documented “beat” target before publishing

4. CBO — Content Brief Optimization

• Build standardized content brief template stored as CMS template or Notion/Airtable database
• Brief must include: target keyword, search intent, target word count, required H2s from PAA + competitor analysis, internal link targets, schema requirements, E-E-A-T elements, primary CTA
• Include keyword cluster (primary + 5–10 semantic variants from SCO research)
• Specify entity coverage requirements per topic (which people, places, concepts must be mentioned)
• Add competitor heading analysis: pull top 3 ranking pages’ H2/H3 structure and identify gaps to fill
• Include freshness baseline: minimum sources, citation count, last-updated cadence
• Validation: Every published page has a completed brief on file, brief checklist shows 100% completion before publish

5. LTO — Long-Tail Keyword Optimization

• Target long-tail queries (4+ words) with dedicated answer pages or article sections
• Place exact long-tail phrase in H1 and within first 60 words of body copy
• Cover related natural language variations and question forms in H2s
• Use AlsoAsked, AnswerThePublic, or Google’s PAA to source full question variants
• Build 50–200 long-tail pages around each pillar to capture full topical demand curve
• Monitor Google Search Console queries report — surface unranked long-tail queries with impressions and target them
• Validation: GSC shows growing impression count on long-tail queries, average position trending up for 4+ word queries

B. Topical Architecture (3)

6. TAO — Topical Authority Optimization

• Map your full topic universe before writing — every sub-topic, related topic, peripheral topic
• Cover the full topic on a hub page with deep sections, then build out cluster pages for every sub-topic
• Aim for completeness, not just keyword targeting — Google rewards sites that comprehensively cover a domain
• Build out 30–50 pages minimum per topical pillar before expanding to a new pillar
• Use schema about and mentions properties to declare topical focus to search engines
• Track topical authority with tools like Inlinks, MarketMuse, or Frase — measure topical coverage score
• Avoid topic drift — every published page must reinforce one of your declared topical pillars
• Validation: Topical authority score (MarketMuse or equivalent) trending up, ranking velocity faster on new pages within established topics

7. PCO — Pillar-Cluster Optimization

• Build pillar page at 3,000+ words covering the full topic with table-of-contents jump links
• Create 8–15 cluster pages per pillar at 1,200+ words each, every cluster page interlinked with the pillar
• Pillar page links to every cluster with descriptive anchor text in dedicated section
• Every cluster page links back to pillar in introduction and conclusion
• Cluster pages cross-link to 3–5 sibling clusters using contextual anchors (not just navigation)
• Add “Last Updated” banner and refresh annually — pillar pages decay fastest
• Use breadcrumb hierarchy: Home → Pillar → Cluster, with BreadcrumbList schema
• Track pillar performance as a unit — measure organic traffic for the entire pillar+cluster group, not just individual pages
• Validation: Pillar-cluster groups show 2–3x organic traffic vs orphan content, internal link equity flows clearly from pillar outward

8. SCO — Semantic Content Optimization

• Use semantic research tools (MarketMuse, Frase, Surfer) to identify required entities and LSI terms per page
• Naturally include semantic variants and related entities in body copy and H2/H3 headings
• Add Schema.org type-specific markup beyond basics: Product, Service, Course, Recipe, HowTo, Event as relevant
• Use mentions and about properties in schema to declare key entities the page covers
• Connect entities across pages using consistent @id references in JSON-LD
• Map content topics to Google’s Knowledge Graph entities where possible (use Wikidata Q-IDs)
• Avoid keyword stuffing — semantic optimization is about conceptual coverage, not term repetition
• Validation: Topical coverage score above 75% in MarketMuse, schema validates with cross-page entity linking intact

C. SERP Feature Targeting (6)

9. FSO — Featured Snippet Optimization

• Answer the target question in the first 40–60 words directly under H2 (paragraph snippet format)
• For “how to” queries use numbered ordered lists with 4–8 steps (list snippet format)
• For comparison queries use HTML tables with header rows (table snippet format)
• Match exact question phrasing in H2 — Google often pulls snippets from heading + following paragraph
• Add FAQPage schema where genuinely applicable, HowTo schema for procedural content
• Identify featured snippet opportunities via Ahrefs “SERP features” filter — target keywords where you rank 2–5 but competitor owns the snippet
• Audit snippet wins monthly — losing a snippet means rewrite, not repost
• Validation: Snippet ownership tracked in dashboard, target page owns snippet for primary query within 60 days of publish

10. PAO — People Also Ask Optimization

• Pull every PAA question for target keyword via AlsoAsked, AnswerThePublic, or manual Google scrape
• Answer each PAA question in dedicated H2 sections on the target page
• Format answers in 40–60 word direct responses followed by expanded detail
• Add FAQPage JSON-LD covering all answered questions on the page
• Click into each PAA to surface nested follow-up questions, target the next layer too
• Track which PAA questions you own — PAA real estate compounds over time
• Avoid forcing irrelevant PAA questions onto a page — only answer questions genuinely related to the page’s intent
• Validation: Page owns at least 30% of PAA slots for primary query within 90 days, FAQ schema validates

11. ZEO — Zero-Click Optimization

• Optimize for queries Google answers directly in SERP (knowledge panels, snippets, calculators, definitions)
• Provide complete on-page answers so users get value even without clicking through (counterintuitive but builds authority)
• Add prominent “Jump to Answer” table of contents at top of every long-form page
• Use definition-style first paragraphs for “what is” queries
• Implement Speakable schema on the most quotable passage of each page
• Optimize for brand searches with structured data so knowledge panel populates with your data, not Wikipedia’s
• Track zero-click impression growth in GSC — these still build brand recall and citation likelihood
• Validation: Brand impressions in GSC grow even when CTR stays flat, knowledge panel shows correct entity data

12. PLO — Passage-Level Optimization

• Optimize individual paragraphs for specific sub-questions, not just the page-level keyword
• Use clear H3/H4 sub-headings that match sub-question phrasing
• Keep each passage self-contained — Google can rank a single paragraph independently
• Add inline Speakable schema on highest-value passages for voice search
• Use semantic HTML5 (<article>, <section>) to delineate passages clearly
• Lead each passage with the answer, follow with elaboration (inverted pyramid)
• Audit GSC for queries ranking on a page where the query matches a passage, not the page topic — these are PLO wins
• Validation: GSC shows long-form pages ranking for 50+ distinct queries each, passages match user query intent

13. BSO — Brand SERP Optimization

• Audit what currently shows when someone searches your exact brand name
• Claim and complete every relevant first-page property: Google Business Profile, LinkedIn company page, Wikipedia, Crunchbase, social profiles
• Optimize the homepage <title> and meta description specifically for brand SERP appearance
• Implement Organization + WebSite + SearchAction schema so sitelinks search box appears
• Build out an “About” page that ranks #2 on brand SERP, controlling secondary narrative
• Monitor brand SERP for negative or off-brand results, address with targeted content or PR
• For founder/personal brand searches, repeat process with Person schema and personal site
• Validation: First page of brand SERP is 100% owned or favorable properties, knowledge panel populated correctly

14. IEO — Image Engine Optimization

• Use descriptive, hyphenated file names (e.g., red-leather-armchair-side-view.webp, not IMG_4823.jpg)
• Write descriptive alt text matching the image’s actual content and the page’s keyword context
• Add ImageObject schema with contentUrl, caption, creator, license, width, height
• Include images in dedicated image sitemap, submit via Google Search Console
• Use surrounding text and captions to reinforce image relevance to target topic
• Compress aggressively while preserving visual quality (WebP/AVIF preferred per Tier 1 WPO)
• For product or recipe images, ensure schema embeds the image in Product/Recipe schema
• Validation: Image sitemap submitted and indexed, GSC Performance > Search Type: Image shows growing impressions

D. Authority & Trust Signals (5)

15. ETO — E-E-A-T Content Trust Optimization

• Add author box at the bottom of every article with photo, name, credentials, and link to author page
• Display “Last Updated” banner at top of every article with verifier name
• Add inline citations with clickable source links for every factual claim, statistic, or quoted material
• Display global trust signals in footer: certifications, awards, “Featured in” logos, security badges
• Build dedicated /about/our-expertise/ page linking to all author bios and listing company credentials
• Display Google review widget or testimonials on key landing pages (with Review or AggregateRating schema)
• Add visible disclosure on affiliate, sponsored, or commercial content per FTC guidelines
• Quarterly review cycle: audit top 20 traffic pages and refresh trust signals
• Validation: Every article has author + last-updated + citations, third-party trust audit (Originality.ai or manual review) scores 8+/10

16. AAO — Author Authority Optimization

• Build dedicated author page per contributor at /authors/name-slug/ with bio (200–400 words), photo, credentials list
• Add Person JSON-LD per author page with sameAs linking to LinkedIn, Twitter/X, GitHub, Wikidata, professional profiles
• Add knowsAbout array listing topical expertise (matches mentions in their published articles)
• Reference author’s external publications, conference talks, podcast appearances, certifications
• Cross-link author page from every article they’ve written and every article that cites them
• Encourage authors to publish on other authoritative sites and link those mentions back via sameAs
• Track author-level rankings — measure how content from your high-authority authors performs vs others
• Validation: Each author page validates as Person schema, GSC shows author-attributed pages outperforming unauthored content

17. NLO — Natural Language Optimization

• Write the first 100 words as a direct, conversational answer to the page’s primary query
• Use full-sentence H2 headings phrased as natural questions (“How does X work?” not “X mechanics”)
• Match conversational query patterns from voice search and AI assistants
• Use second-person (“you”) and active voice for engagement
• Avoid jargon walls — define technical terms inline on first use
• Read every page out loud before publishing — if it sounds robotic, rewrite
• Test target queries against Google Assistant and ChatGPT to see what natural language returns
• Validation: Flesch reading ease 60+, voice search test surfaces page or content quoted from page

18. ESO — Entity Salience Optimization

• Identify primary entity per page (the one thing the page is about) using Google’s Natural Language API or Inlinks
• Reinforce primary entity in title, H1, first paragraph, URL, image alt text, and schema
• Use exact entity name consistently — avoid synonyms that dilute salience
• Include 5–10 strongly related entities on the page (people, places, organizations, concepts)
• Cross-reference entities across pages using consistent @id URIs in JSON-LD
• Test salience post-publish: paste page into Google’s Cloud NLP demo and confirm entity hierarchy matches intent
• Avoid entity overlap between competing pages on your site (cannibalization risk)
• Validation: Google NLP API returns target entity as the most salient, salience score above 0.7

19. SXO — Search Experience Optimization

• Write title tags and meta descriptions that match SERP intent and emotional trigger of query
• Include CTR-boosting modifiers in titles: year, “best”, “ultimate”, “complete”, numbers, brackets
• Test title and description previews via SERP simulator (e.g., Mangools SERP Simulator) before publishing
• Match landing page experience to SERP promise — no bait-and-switch
• Optimize page above-the-fold to confirm intent immediately (user shouldn’t have to scroll to verify they’re in the right place)
• Reduce SERP-to-conversion friction: clear CTAs, fast load, intuitive navigation per Tier 1 UXO
• A/B test titles on top 20 pages using GSC data — measure CTR delta over 30-day windows
• Validation: GSC CTR for top 20 pages above category average, bounce rate below 50% on landing pages

E. Link & Off-Page Signals (4)

20. OPO — Off-Page Optimization

• Create dedicated /press/ or /media/ page with press kit, brand assets, executive bios, contact info
• Add “As Seen In” section on homepage and About page with logos linking to coverage
• Build embeddable assets (calculators, infographics, original data) with built-in attribution requirement
• Maintain consistent NAP (Name, Address, Phone) across all citation sources — match exactly to LocalBusiness schema
• Submit to relevant industry directories and association sites (skip generic low-quality directories)
• Earn unlinked brand mentions and convert them via outreach (use Brand24 or Mention to track)
• Pursue podcast guest appearances and conference speaking — both build entity authority and natural backlinks
• Validation: Referring domain count growing month-over-month, NAP consistency 100% across top 20 citation sources

21. LBO — Link Building Optimization

• Build linkable assets first: original research, ultimate guides, free tools, data studies on dedicated pages
• Add prominent “Share & Cite” section at end of every high-value page with copy-paste citation block
• Run digital PR campaigns around proprietary data and research findings
• Pursue resource page link inclusion — find competitor backlinks via Ahrefs, identify shared opportunities
• Use HARO/Qwoted/SourceBottle to source journalist requests and place expert commentary
• Avoid paid link schemes, PBNs, low-quality guest post networks — risk outweighs reward
• Track link velocity to avoid unnatural spikes that trigger manual review
• Validation: Domain Rating trending up, new referring domains exceed lost referring domains monthly, zero unnatural pattern flags

22. ILO — Internal Linking Optimization

• Add 8–15 contextual internal links per long-form article using descriptive anchor text
• Link from high-authority pages to underperforming pages that need equity
• Place “Related Articles” widget at bottom of every article (3–6 manually curated links, not auto-generated)
• Audit orphan pages quarterly — every published page should have at least 3 internal links pointing to it
• Use exact-match or partial-match anchor text for internal links (no algorithm penalty for internal anchors)
• Avoid sitewide footer links to specific pages — they look manipulative and dilute equity
• Map internal link flow with Sitebulb or Screaming Frog — visualize equity distribution
• Validation: Zero orphan pages in latest crawl, average internal links per page 8+, link equity report shows balanced flow

23. OLO — Outbound Link Optimization

• Link out to 2–5 authoritative sources per article (research papers, government data, official documentation)
• Use rel="noopener" on all external links, rel="nofollow sponsored" on paid/affiliate links per Google policy
• Use rel="ugc" on user-generated content links (comments, forum posts)
• Open external links in same tab unless user expectation suggests otherwise — target="_blank" only when justified
• Audit outbound links quarterly — replace dead links, remove links to declining/spammy domains
• Cite primary sources, not aggregators — Wikipedia is acceptable for definitions, not for facts
• Outbound links to authoritative sources signal that you’re a connected, well-researched node in the topic graph
• Validation: Zero broken outbound links in latest crawl, every article has at least 2 authoritative external citations

F. Content Lifecycle & Maintenance (5)

24. CLO — Content Lifecycle Optimization

• Add “Last Updated” date and banner at top of every article with verifier signature
• Schedule quarterly content review cycle — top 20% of pages reviewed every 90 days
• Update dateModified in Article schema on every meaningful refresh (not minor typo fixes)
• Establish content tier system: evergreen (refresh annually), seasonal (refresh per cycle), news (no refresh)
• Track content decay via GSC — pages losing 20%+ traffic month-over-month flagged for refresh
• Refresh checklist per page: stats updated, sources current, internal links revised, CTAs aligned, schema validated
• Retire and 301-redirect content that no longer serves — pruning improves overall site quality signal
• Validation: Average content age per pillar under 18 months, traffic recovery on refreshed pages within 30 days

25. DCA — Disavow & Toxic Link Cleanup

• Audit backlink profile monthly via GSC + Ahrefs/Semrush, flag suspicious patterns (PBN footprints, foreign-language spam, link networks)
• Maintain internal disavow log (password-protected admin page) tracking every disavowed domain with reason and date
• Submit disavow file via Google Search Console only after manual outreach to remove toxic links fails
• Disavow at the domain level, not URL level, when an entire site is toxic
• Re-evaluate disavow file quarterly — remove entries from domains that have cleaned up
• Document everything for potential manual action defense
• Avoid over-disavowing — Google’s algorithm handles most spam without disavow file
• Validation: Toxic link percentage below 5% of total backlinks, zero unresolved manual actions in GSC

26. LRE — Link Reclamation & Broken Link Fix

• Set up 404 monitoring with auto-alert on broken inbound links (Cloudflare logs, GSC Coverage report, dedicated tool)
• Fix every broken inbound link with a 301 to the most relevant live page
• Monitor unlinked brand mentions via Brand24, Mention, or Google Alerts — convert via outreach
• Reclaim lost backlinks: identify referring domains that previously linked but no longer do, investigate cause
• Audit competitor broken backlinks — pitch your equivalent content as replacement
• Track every reclamation attempt in CRM or spreadsheet with status, owner, date
• Build relationship with high-authority publishers — they’re more likely to update links when asked
• Validation: Zero broken inbound links to high-traffic pages, monthly reclamation rate above 25% of identified opportunities

27. CSO — Click Signal Optimization

• Track CTR per page via GSC Performance report — identify high-impression / low-CTR pages
• Rewrite titles and meta descriptions on underperforming pages, target +20% CTR lift
• Use power words, numbers, brackets, year, and emotional triggers in titles where appropriate
• Match meta description tone to query intent — informational queries want educational tone, transactional want value props
• Test favicon visibility on mobile SERP — your icon affects CTR per Tier 1 FIO
• Add structured data that produces rich snippets (review stars, FAQ, recipe, product) — rich results lift CTR
• Monitor average position vs CTR by page; if CTR drops while position holds, refresh title/description
• Validation: Top 50 pages show CTR above category average, CTR lift documented after every title rewrite

28. SVM — SERP Volatility Monitoring

• Subscribe to SERP volatility trackers: Semrush Sensor, MozCast, Advanced Web Rankings
• Set up rank tracking for top 100 priority keywords with daily updates
• Configure alerts for ranking drops over 5 positions on priority keywords
• Document every Google algorithm update (core, helpful content, spam, reviews) and correlate with traffic changes
• Maintain incident log: date, suspected update, pages affected, traffic delta, action taken
• Avoid panic-rewriting after a single ranking drop — wait 7–14 days for SERP to stabilize before reacting
• Track competitor ranking changes alongside yours — sometimes a drop is everyone losing to a new entrant
• Validation: All algorithm updates logged with impact analysis within 7 days, rank tracking dashboard reviewed weekly

Summary

• Total items: 28
• Sub-clusters: 6 (Content Strategy & Research, Topical Architecture, SERP Feature Targeting, Authority & Trust Signals, Link & Off-Page Signals, Content Lifecycle & Maintenance)
• Format: Each item includes 6–8 implementation steps plus a validation criterion
• Net change from original: 6 dropped, 4 consolidated to 2, 9 added, 6 renamed for consistent 3-letter codes
• Position in stack: Visibility tier — depends on Tier 1 Foundation, feeds into Tier 3 AI Domination

About this series

This is one of 14 articles in ThatDevPro’s Engine Optimization stack — a productized SEO + AEO + AIO + GEO service. Each tier is a self-contained framework with concrete checklists, validation steps, and code patterns.

Canonical source for this article: https://www.thatdevpro.com/insights/seo-tier-2-search-visibility/

The 14-tier series:

1. Tier 1 — Foundation
2. Tier 2 — Search Visibility
3. Tier 3 — AI Domination
4. Tier 4 — Entity and Authority
5. Tier 5 — Local Domination
6. Tier 6 — Content and Multimedia
7. Tier 7 — Social and Community
8. Tier 8 — Data, Analytics, Conversion
9. Tier 9 — Monitoring and Intelligence
10. Tier 10 — Workflow and Operations
11. Tier 11 — Marketplace and Retail
12. Tier 12 — International
13. Tier 14 — Advanced and Immersive

Tier 13 is retired.

Need this implemented on your site? ThatDevPro ships the full 14-tier stack as a productized service. SDVOSB-certified veteran-owned. Cassville, Missouri. See the Engine Optimization service.

Open-source tooling powering this series:

• aio-surfaces — Python toolkit (MIT) for generating llms.txt + aeo.json + entity.json + brand.json
• llms.txt generator — live Hugging Face Space

Originally published at thatdevpro.com. This article 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 republish; the canonical source is on ThatDevPro.com. Source repo for the AI-citation surfaces: github.com/Janady13/aio-surfaces.

Tier Explanation: Non-negotiable technical bedrock. Every page, server config, and CMS gets these implemented before any other tier is touched. Items are grouped into five sub-clusters so the audit reads as a framework, not a list.

Related Frameworks

This tier implements the following framework documents in the /Framework/ library. Consult them for canonical reference, audit rubrics, and detailed implementation patterns.

• framework-technicalseo.md — Crawlability, indexing, canonicalization, redirects, URL structure
• framework-schema.md — JSON-LD, @id graph pattern, Organization/Person/WebSite/BreadcrumbList
• framework-pageexperience.md — Core Web Vitals (LCP, INP, CLS), mobile usability, HTTPS
• framework-internallinking.md — Hub-and-spoke architecture, anchor text, crawl depth
• framework-mobileseo.md — Mobile-first indexing, mobile usability
• framework-security.md — Security headers, HSTS, broader security posture

A. Crawlability & Indexing (10)

1. TSO — Technical SEO Optimization

• Set WordPress permalinks to /%postname%/; in Next.js use file-based routing with consistent trailing-slash policy (pick one, stick to it sitewide)
• Add <link rel="canonical" href="https://yourdomain.com/exact-current-url/"> to every page <head>, self-referencing on canonical pages
• Add <meta name="robots" content="index, follow, max-image-preview:large, max-snippet:-1"> to indexable pages
• Force lowercase URLs in .htaccess or nginx.conf to prevent case-duplicate indexing
• Resolve www/non-www and http/https with a single 301 redirect (one hop only, no chains)
• 301-redirect or 410 all thin, duplicate, or orphan pages flagged in GSC
• Validation: Screaming Frog crawl shows zero duplicate canonicals, zero redirect chains, zero mixed-case URLs

2. ARC — Site Architecture Optimization

• Limit every page to a maximum of 3 clicks from homepage (use Sitebulb’s Crawl Depth report to verify)
• Add breadcrumb navigation to every non-homepage template with BreadcrumbList JSON-LD
• Build a public /sitemap.html listing all top-level sections and key pages
• Implement hub-and-spoke topical clusters: pillar page links to 5–15 sub-pages, each sub-page links back
• Use descriptive anchor text on internal links (no “click here”, no “read more” without context)
• Keep URL slugs under 60 characters, no stop words, hyphens only
• Validation: Crawl depth report shows zero pages beyond depth 3, breadcrumbs validate in Rich Results Test

3. MTO — Meta Tag Optimization

• Write unique <title> tag per page, 50–60 characters, primary keyword near the front
• Write unique <meta name="description"> per page, 140–160 characters, with active voice and CTA
• Add full Open Graph set: og:title, og:description, og:image (1200×630), og:type, og:url
• Add Twitter Card tags: twitter:card="summary_large_image", twitter:title, twitter:description, twitter:image
• Add <meta name="theme-color"> matching brand color for mobile browser chrome
• Add <meta http-equiv="Content-Language"> and <html lang="en"> for language signals
• Validation: Run every URL through metatags.io and OpenGraph.xyz, screenshots match expected previews

4. SDO — Structured Data Optimization

• Insert Organization and WebSite JSON-LD in <head> of every page (with SearchAction for sitelinks search)
• Add LocalBusiness schema with full NAP, hours, geo coordinates, and areaServed for any business with a physical address
• On article pages add Article + Author (Person) + datePublished + dateModified JSON-LD
• On service pages add Service schema with provider, areaServed, hasOfferCatalog
• On FAQ sections add FAQPage JSON-LD (only when content genuinely answers questions)
• Use absolute URLs in all @id values to enable cross-schema linking
• Validation: Every page passes Google Rich Results Test and Schema.org validator with zero errors

5. XSO — XML Sitemap Optimization

• Enable dynamic XML sitemap via Yoast, Rank Math, or framework plugin (Next.js: next-sitemap)
• Confirm <lastmod> updates on every content edit, not just on publish
• Split sitemaps when over 50,000 URLs or 50MB into a sitemap index
• Exclude noindex pages, redirects, and parameter URLs from the sitemap
• Add separate image sitemap and video sitemap when applicable
• Submit sitemap URL in Google Search Console and Bing Webmaster Tools
• Validation: Sitemap returns 200, validates as XML, and all listed URLs are indexable

6. RPO — Robots Protocol Optimization

• Create exact /robots.txt at root:

  User-agent: *
  Allow: /
  Disallow: /wp-admin/
  Disallow: /staging/
  Disallow: /*?*sessionid=

  Sitemap: https://yourdomain.com/sitemap.xml

• Add explicit User-agent: GPTBot, User-agent: ClaudeBot, User-agent: PerplexityBot rules (allow or disallow per client preference)
• Block known scraper bots (SemrushBot, AhrefsBot) only if the client requests it — not by default
• Never block CSS, JS, or image directories — Google needs them to render
• Test in Google Search Console robots.txt tester before deploying
• Validation: yourdomain.com/robots.txt returns 200 plain text, GSC tester shows zero blocked critical resources

7. RDO — Redirect Optimization

• Add 301 redirects only via server config (.htaccess, nginx, Cloudflare Rules) — never JS or meta refresh
• Eliminate redirect chains — every redirect points directly to the final URL
• Fix every 404 in GSC Coverage report with a 301 to the most relevant live URL, or return 410 if intentionally gone
• Use 302 only for true temporary redirects (A/B tests, seasonal pages)
• Maintain a redirect map spreadsheet for every site migration or restructure
• Validation: Screaming Frog shows zero chains, zero 302s on permanent moves, zero 4xx in sitemap

8. EEA — E-E-A-T Entity Optimization

• Add Person JSON-LD for the business owner with sameAs linking to Wikidata, LinkedIn, GitHub, social profiles
• Reference your Wikidata Q-ID in author schema across all editorial content
• Add knowsAbout array to Person schema listing topical expertise areas
• Build out an author page per content contributor with bio, credentials, photo, and social links
• Cross-link Organization schema to founder Person schema via founder property
• Claim and complete Google Business Profile with verified ownership
• Validation: Person schema validates, Wikidata entry resolves, knowledge panel candidate eligibility confirmed

9. INO — IndexNow Optimization

• Generate IndexNow API key, place at /{key}.txt at root
• Install IndexNow plugin (WordPress) or add publish-hook API call (Next.js, custom CMS)
• Submit every new and updated URL via POST on save/publish
• Use the urlList batch endpoint for bulk submissions during migrations
• Monitor submission logs to confirm 200 responses from Bing/Yandex
• Validation: Test submission returns HTTP 200, URL appears in Bing index within 24 hours

10. LMO — llms.txt Optimization

• Create /llms.txt at root with site purpose, key URLs, and crawler rules
• Create expanded /llms-full.txt with full markdown context for AI training and retrieval
• Reference both files from robots.txt via Sitemap: style declarations
• Format llms.txt per the emerging spec: H1 title, blockquote summary, sectioned link lists
• Update on major content additions so AI crawlers retrieve fresh context
• Validation: Both files return 200 plain text, llms.txt validates against current spec

B. Performance (8)

11. CTO — Core Technical Optimization

• Enable Brotli compression at the edge, Gzip as fallback (brotli on; brotli_types text/css application/javascript)
• Set Cache-Control: public, max-age=31536000, immutable on all hashed static assets
• Set Cache-Control: public, max-age=3600, s-maxage=86400 on HTML pages
• Add security headers: X-Content-Type-Options: nosniff, X-Frame-Options: SAMEORIGIN, Referrer-Policy: strict-origin-when-cross-origin, Permissions-Policy: camera=(), microphone=()
• Enable OCSP stapling for faster TLS handshake
• Disable server signature/version disclosure (server_tokens off in nginx)
• Validation: securityheaders.com returns A+ grade, GTmetrix shows compression active

12. CDN — Content Delivery Network Configuration

• Route all traffic through Cloudflare, Fastly, or Bunny CDN with origin shielding enabled
• Replace all image, CSS, and JS URLs with CDN-hosted URLs in theme settings
• Enable edge caching for HTML pages with Cache-Tag headers for selective purging
• Set proper Vary headers (Vary: Accept-Encoding, Accept) so personalization doesn’t break cache
• Configure cache purge webhook on publish/update events
• Enable Cloudflare Polish (or equivalent) for automatic image optimization at edge
• Validation: cf-cache-status: HIT on second request, edge response time under 50ms

13. HTO — HTTP/3 and QUIC Optimization

• Confirm origin server negotiates HTTP/3 with Alt-Svc: h3=":443" header
• Enable HTTP/3 in Cloudflare dashboard or nginx (listen 443 quic reuseport)
• Fall back gracefully to HTTP/2, never serve HTTP/1.1 over TLS
• Enable 0-RTT resumption only on idempotent requests (GET, HEAD)
• Keep TLS 1.3 enabled, disable TLS 1.0 and 1.1 entirely
• Validation: http3check.net confirms H3, SSL Labs returns A+ with TLS 1.3 only

14. DPO — DNS Preconnect Optimization

• Add <link rel="preconnect" href="https://fonts.googleapis.com" crossorigin> for every third-party origin used above the fold
• Add <link rel="dns-prefetch" href="https://example.com"> as fallback for non-critical origins
• Preload LCP image: <link rel="preload" as="image" href="hero.webp" fetchpriority="high">
• Preload critical fonts: <link rel="preload" href="font.woff2" as="font" type="font/woff2" crossorigin>
• Use fetchpriority="low" on below-the-fold images and non-critical resources
• Limit total preconnects to 4–6 to avoid contention
• Validation: WebPageTest waterfall shows DNS/TLS handshakes complete before resource fetch

15. WPO — Web Performance Optimization

• Convert all images to AVIF with WebP fallback, JPEG/PNG as last resort
• Serve responsive images via <picture> element with srcset and sizes
• Add loading="lazy" to every image below the fold (above-the-fold images use loading="eager")
• Add decoding="async" to all images
• Minify CSS, JS, and HTML in production build (Terser, cssnano, html-minifier)
• Tree-shake unused JS/CSS — audit with Coverage tab in Chrome DevTools
• Remove unused fonts and font weights
• Validation: PageSpeed Insights “Properly size images” and “Efficient image formats” both pass

16. CWV — Core Web Vitals Optimization

• Target LCP under 2.5s — preload LCP element, optimize hero image, eliminate render-blocking
• Target INP under 200ms — break up long tasks, debounce input handlers, defer non-critical JS
• Target CLS under 0.1 — reserve space for ads/embeds, set image dimensions, avoid late-loading content
• Add content-visibility: auto to below-the-fold sections
• Use will-change: transform only on actively animating elements (remove after animation)
• Monitor field data via CrUX dashboard and PageSpeed Insights, not just lab data
• Validation: All three metrics in “Good” bucket for 75th percentile in CrUX over 28-day window

17. CRP — Critical Rendering Path Optimization

• Inline above-the-fold critical CSS in <style> inside <head> (target under 14KB)
• Async-load remaining CSS: <link rel="preload" href="full.css" as="style" onload="this.rel='stylesheet'">
• Add font-display: swap to every @font-face rule to eliminate invisible text
• Subset fonts to Latin characters only when full Unicode isn’t needed
• Move all non-critical JS to footer with defer attribute
• Self-host fonts when possible to eliminate third-party origin handshake
• Validation: Lighthouse “Eliminate render-blocking resources” passes, FCP under 1.8s

18. RNO — Render Optimization

• Use defer on scripts that depend on DOM, async on independent scripts (analytics, ads)
• Avoid document.write() entirely — it blocks parsing
• Move all third-party tags (chat widgets, analytics, pixels) to load after window.load event
• Use Partytown or web workers to offload third-party JS off main thread
• Lazy-load embeds (YouTube, maps, social) with click-to-load facade pattern
• Audit main thread time in DevTools Performance panel — target under 2s on Slow 4G
• Validation: Lighthouse “Reduce JavaScript execution time” under 2 seconds, no long tasks over 50ms

C. Experience & Access (5)

19. UXO — User Experience Optimization

• Add <meta name="viewport" content="width=device-width, initial-scale=1"> to every page
• Set body font size minimum 16px, line-height 1.5–1.6, max line length 75 characters
• Make all tap targets minimum 48×48px with 8px+ spacing between them
• Maintain minimum 4.5:1 contrast ratio for body text, 3:1 for large text
• Test on real devices: iPhone SE (smallest common viewport), Android mid-range, iPad
• Eliminate horizontal scroll at all viewport widths from 320px to 2560px
• Add prefers-reduced-motion media query to disable non-essential animations
• Validation: Google Mobile-Friendly Test passes, manual touch test on real device confirms usability

20. ACO — Accessibility Optimization

• Add descriptive alt text to every meaningful image; use alt="" for decorative images only
• Add aria-label to icon-only buttons and links
• Use exactly one <h1> per page with logical H2–H6 hierarchy (no skipped levels)
• Place skip-to-content link as first focusable element on every page
• Ensure full keyboard navigability — Tab order matches visual order, focus indicators visible
• Use semantic HTML5: <nav>, <main>, <article>, <aside>, <footer> — not <div> everywhere
• Add aria-live regions for dynamic content (form errors, cart updates, search results)
• Validation: axe DevTools shows zero violations, manual keyboard-only navigation completes all key flows

21. IDO — Image Dimensions Optimization

• Set explicit width and height attributes on every <img> and <video> element
• Use aspect-ratio CSS property on responsive images to reserve space before load
• For background images, set min-height on container so layout doesn’t shift on load
• For ads, embeds, and iframes, reserve fixed dimensions or use placeholder containers
• Use <picture> with art-directed sources for different aspect ratios per breakpoint
• Audit CLS contributors in PageSpeed Insights “Avoid large layout shifts” report
• Validation: CLS score under 0.1 in field data, zero images flagged in Lighthouse layout-shift audit

22. FIO — Favicon and Icon Optimization

• Generate full icon set: favicon.ico (32×32), apple-touch-icon.png (180×180), icon-192.png, icon-512.png
• Add complete <link> tag set in <head>:

  <link rel="icon" type="image/x-icon" href="/favicon.ico">
  <link rel="icon" type="image/png" sizes="32x32" href="/icon-32.png">
  <link rel="apple-touch-icon" href="/apple-touch-icon.png">
  <link rel="manifest" href="/site.webmanifest">

• Create site.webmanifest with name, short_name, icons array, theme_color, background_color
• Add <meta name="theme-color"> matching brand for mobile browser chrome
• Use SVG favicon for crisp rendering at all sizes when supported
• Validation: realfavicongenerator.net checker passes all platforms, icons display in browser tabs/bookmarks

23. EPO — Error Page Optimization

• Create custom 404 page with helpful navigation: search bar, top categories, recent posts, contact link
• Return proper HTTP status codes — 404 for not found, 410 for permanently gone, never soft-404
• Create custom 500/503 pages with brand styling and contact info
• Monitor GSC Coverage report weekly for soft-404s and crawl errors
• Set up Cloudflare/server alerts for spikes in 4xx and 5xx responses
• Log all 404s to identify broken inbound links worth redirecting
• Validation: 404 pages return HTTP 404 (not 200), GSC shows zero soft-404 errors

D. Security & Compliance (2)

24. SSO — Site Security Optimization

• Enforce HTTPS sitewide with HSTS header: Strict-Transport-Security: max-age=31536000; includeSubDomains; preload
• Submit domain to HSTS preload list at hstspreload.org
• Add Content Security Policy header tailored to actual third-party sources
• Enable automatic CMS, plugin, and theme security updates with rollback capability
• Implement WAF rules via Cloudflare or Sucuri (block SQLi, XSS, known bot signatures)
• Force strong admin passwords + 2FA on all CMS accounts
• Disable XML-RPC in WordPress unless actively used
• Run weekly malware scan (Wordfence, Sucuri, MalCare)
• Validation: SSL Labs A+, securityheaders.com A+, zero vulnerabilities in WPScan or equivalent

25. GCO — GDPR and Compliance Optimization

• Install consent banner that blocks all non-essential scripts until consent (Cookiebot, Termly, Iubenda)
• Categorize cookies: strictly necessary, performance, functional, marketing — load only consented categories
• Add comprehensive privacy policy with footer link covering data collected, purpose, retention, third parties, rights
• Add “Your Privacy Choices” link in footer for U.S. state privacy laws (CA, CO, CT, VA, UT, TX, OR, MT)
• Implement Google Consent Mode v2 for ad and analytics consent signals
• Add accessibility statement page covering WCAG conformance level
• Add terms of service and DMCA contact for U.S. compliance
• Validation: Cookie scanner shows zero scripts firing pre-consent, privacy policy reviewed by qualified counsel

E. Modern Web (3)

26. JSO — JavaScript SEO

• Use server-side rendering (Next.js SSR/SSG, Astro, Nuxt) — never rely on pure client-side rendering for content pages
• For SPAs, implement dynamic rendering or pre-rendering for bot user agents as fallback
• Add <noscript> fallback for critical content and navigation
• Verify rendered HTML contains all SEO-critical content (title, headings, body copy, links) via View Source
• Test every template in Google Mobile-Friendly Test and URL Inspection’s “Live Test”
• Avoid hash-based routing (/#/page) — use clean paths only
• Validation: Rendered HTML in GSC URL Inspection matches View Source, all content visible to bot

27. PWO — PWA Optimization

• Create /manifest.json (or /site.webmanifest) with name, short_name, start_url, display, theme_color, icons
• Register service worker for offline fallback page and asset caching
• Use Workbox or framework PWA plugin to manage cache strategies (cache-first, network-first, stale-while-revalidate)
• Add install prompt button that appears after beforeinstallprompt event
• Test offline mode in Chrome DevTools Application panel
• Keep service worker scope and cache version controlled to avoid stale-content issues
• Validation: Lighthouse PWA audit passes, app installs from browser on Android and desktop

28. LFO — Log File Optimization

• Enable server access logs in nginx/Apache with full request data (status, user-agent, response time)
• Block low-value bots in robots.txt and at WAF level (SemrushBot, MJ12bot, DotBot per client preference)
• Run monthly log analysis with Screaming Frog Log File Analyzer or Botify
• Identify pages Googlebot crawls but rarely — candidates for internal link reinforcement
• Identify pages Googlebot crawls excessively but rank poorly — candidates for noindex or consolidation
• Monitor crawl budget allocation between Googlebot, Bingbot, and AI crawlers
• Validation: Log analysis report shows Googlebot reaching all priority URLs within 30-day window

Summary

• Total items: 28
• Sub-clusters: 5 (Crawlability & Indexing, Performance, Experience & Access, Security & Compliance, Modern Web)
• Format: Each item includes 5–7 implementation steps plus a validation criterion
• Position in stack: Foundation tier — all subsequent tiers (T2 Search Visibility, T3 AI Domination, etc.) depend on this layer being implemented first

About this series

This is one of 14 articles in ThatDevPro’s Engine Optimization stack — a productized SEO + AEO + AIO + GEO service. Each tier is a self-contained framework with concrete checklists, validation steps, and code patterns.

Canonical source for this article: https://www.thatdevpro.com/insights/seo-tier-1-foundation/

The 14-tier series:

1. Tier 1 — Foundation
2. Tier 2 — Search Visibility
3. Tier 3 — AI Domination
4. Tier 4 — Entity and Authority
5. Tier 5 — Local Domination
6. Tier 6 — Content and Multimedia
7. Tier 7 — Social and Community
8. Tier 8 — Data, Analytics, Conversion
9. Tier 9 — Monitoring and Intelligence
10. Tier 10 — Workflow and Operations
11. Tier 11 — Marketplace and Retail
12. Tier 12 — International
13. Tier 14 — Advanced and Immersive

Tier 13 is retired.

Need this implemented on your site? ThatDevPro ships the full 14-tier stack as a productized service. SDVOSB-certified veteran-owned. Cassville, Missouri. See the Engine Optimization service.

Open-source tooling powering this series:

• aio-surfaces — Python toolkit (MIT) for generating llms.txt + aeo.json + entity.json + brand.json
• llms.txt generator — live Hugging Face Space

Originally published at thatdevpro.com. This article 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 republish; the canonical source is on ThatDevPro.com. Source repo for the AI-citation surfaces: github.com/Janady13/aio-surfaces.

Tier Explanation: Makes the entire optimization system scalable, repeatable, and efficient. In 2026, automation, CRM integration, AI-assisted workflows, and process repeatability are critical for maintaining quality at scale while reducing manual work. All actions execute on website integrations, CMS templates, automation tools, and internal documentation. Tiers 1–9 must be in place first.

Related Frameworks

This tier implements the following framework documents in the /Framework/ library. Consult them for canonical reference, audit rubrics, and detailed implementation patterns.

• framework-clientonboarding.md — New-client engagement onboarding
• framework-pricing.md — Pricing and packaging methodology
• framework-ongoingaudit.md — Repeatable audit cycles
• framework-contentaudit.md — Content audit cycle
• framework-reporting.md — Reporting deliverables
• framework-initialaudit.md — New-client audit template

A. Automation & AI-Assisted Operations (3)

1. WAO — Workflow Automation Optimization

• Integrate Zapier, Make.com, or n8n webhooks on publish, update, form-submit, and conversion events
• Automate content approval workflows: draft → review → SEO check → publish → distribute
• Build automated SEO checklist that runs on every publish (schema validates, meta tags present, images optimized)
• Create notification flows: new lead → Slack channel + email + CRM, new content → social distribution queue
• Use webhook signatures to verify authenticity of automation triggers
• Document every automation in a central registry with owner, purpose, and failure protocol
• Test automations weekly — broken automations cause silent data loss
• Track automation ROI: hours saved × hourly rate vs cost of tools

Code Example — Webhook-triggered publish automation:

<!-- CMS publish hook fires automation -->
<script>
async function onContentPublish(article) {
  // 1. Validate SEO checklist
  const seoCheck = await fetch('/api/seo/validate', {
    method: 'POST',
    body: JSON.stringify({url: article.url})
  }).then(r => r.json());

  if (!seoCheck.passed) {
    return notifyAuthor(article.author, seoCheck.issues);
  }

  // 2. Trigger distribution workflow
  await fetch('https://hooks.zapier.com/hooks/catch/YOUR_HOOK', {
    method: 'POST',
    body: JSON.stringify({
      event: 'content_published',
      article: {
        url: article.url,
        title: article.title,
        author: article.author,
        cluster: article.cluster
      }
    })
  });

  // 3. Notify Slack
  await fetch(process.env.SLACK_WEBHOOK, {
    method: 'POST',
    body: JSON.stringify({
      text: `📢 New article published: <${article.url}|${article.title}>`
    })
  });
}
</script>

• Validation: Automation registry maintained, weekly test cycle active, time savings tracked monthly

2. AIW — AI-Assisted Workflow Optimization (new)

• Integrate AI tools (Claude, ChatGPT, Perplexity API) into content workflow for drafting, editing, and ideation
• Use AI for content brief generation from competitor analysis and keyword research
• Automate technical SEO audits with AI-powered tools (ZipTie, AlphaRank, MarketBrew)
• Build AI-assisted code review for schema validation and structured data
• Use AI summarization for long-form content repurposing per Tier 6 CRO
• Maintain human-in-the-loop review for all AI-generated content — never publish without human edit
• Document AI tool usage in style guide to prevent voice drift across team
• Track AI tool ROI vs manual work to optimize investment

Code Example — AI-assisted SEO audit endpoint:

<form action="/api/ai/audit-page" method="POST" class="ai-audit-form">
  <label for="audit-url">URL to audit</label>
  <input type="url" id="audit-url" name="url" required>
  <button type="submit">Run AI Audit</button>
</form>

<script>
// Server-side: passes URL content to Claude API for analysis
// Returns prioritized recommendations: schema gaps, content depth issues,
// E-E-A-T weaknesses, AI extractability problems
</script>

<section class="audit-results">
  <h2>AI-Generated Recommendations</h2>
  <ul id="recommendations">
    <li class="priority-high">Add `Author` schema with credentials</li>
    <li class="priority-high">First paragraph lacks direct answer for AI extraction</li>
    <li class="priority-medium">Missing `dateModified` — content appears stale</li>
  </ul>
</section>

• Validation: AI tools integrated into 3+ workflow steps, human review required on all AI output, ROI tracked vs manual baseline

3. PRP — Process Repeatability Optimization (renamed from PRO)

• Create standardized page templates with locked SEO fields (title, schema, E-E-A-T blocks)
• Build mandatory content brief checklist in CMS that blocks publishing until complete
• Document SOPs on password-protected internal wiki with step-by-step instructions
• Use templates for recurring tasks: monthly reports, quarterly audits, annual planning
• Build “publish-ready” checklist enforced via pre-publish validation
• Use code linters and pre-commit hooks for consistent code quality
• Maintain version-controlled SOPs with change history
• Onboard new team members against documented SOPs, not tribal knowledge

Code Example — CMS pre-publish validation:

<form id="publish-form" data-validation="strict">
  <label>Article Title (50-60 chars)</label>
  <input type="text" name="title" required minlength="40" maxlength="65">

  <label>Meta Description (140-160 chars)</label>
  <input type="text" name="meta_desc" required minlength="120" maxlength="170">

  <label>Author (must be assigned)</label>
  <select name="author" required>
    <option value="">Select author...</option>
  </select>

  <fieldset class="checklist">
    <legend>Pre-Publish Checklist</legend>
    <label><input type="checkbox" name="schema_added" required> Schema added and validated</label>
    <label><input type="checkbox" name="internal_links" required> 8+ internal links added</label>
    <label><input type="checkbox" name="images_optimized" required> Images optimized with alt text</label>
    <label><input type="checkbox" name="cta_added" required> Primary CTA placed</label>
  </fieldset>

  <button type="submit">Publish</button>
</form>

• Validation: All pages publish through validated template, SOPs version-controlled, new hires onboard via documentation in under 2 weeks

B. Documentation & Quality (3)

4. DOC — Documentation & SOP System (new)

• Build centralized documentation hub (Notion, Confluence, GitBook, self-hosted)
• Document every recurring task as SOP with screenshots, video walkthroughs, and decision trees
• Maintain “Definition of Done” per task type
• Build searchable knowledge base for team members and clients
• Use video documentation (Loom, Tella) for complex workflows
• Update SOPs within 7 days of process changes
• Track SOP usage metrics — which docs get viewed, which need updates
• Pair SOPs with templates that auto-populate the right structure

Code Example — Internal documentation hub:

<section class="docs-hub" data-noindex="true">
  <h1>SOP Library</h1>

  <input type="search" placeholder="Search SOPs..." id="sop-search">

  <article class="sop-card">
    <h2>Publishing a New Blog Post</h2>
    <p>Owner: Joseph · Last updated: April 29, 2026 · Used 47 times this month</p>

    <ol>
      <li>Complete content brief (template: <a href="/templates/content-brief">link</a>)</li>
      <li>Draft in CMS using "Article" template</li>
      <li>Run AI audit (PRP step 14): <a href="/admin/ai-audit">link</a></li>
      <li>Add Article + Author schema (template: <a href="/snippets/article-schema">link</a>)</li>
      <li>Validate via Google Rich Results Test</li>
      <li>Cross-link to 8+ related articles</li>
      <li>Set publish date, trigger distribution workflow</li>
    </ol>

    <video src="/sops/publishing-walkthrough.mp4" controls></video>
  </article>
</section>

• Validation: 50+ documented SOPs covering all recurring tasks, average usage per SOP tracked, update SLA met within 7 days

5. QAO — Quality Assurance Optimization (new)

• Build pre-publish QA checklist enforced via automated tooling
• Run automated link checking, schema validation, accessibility audits before publish
• Implement peer review for all client-facing content
• Track QA defect rate per content type — defects per 100 pages published
• Build post-publish audit cadence: 24-hour quick check, 7-day deep audit
• Use staging environment for pre-launch QA — never publish straight to production
• Document QA failures in incident log with root cause and prevention plan
• Train team on QA standards quarterly with real defect examples

Code Example — Automated pre-publish QA check:

<script>
// Pre-publish hook - runs before content goes live
async function runQA(articleId) {
  const checks = await Promise.all([
    fetch(`/api/qa/links?id=${articleId}`).then(r => r.json()),
    fetch(`/api/qa/schema?id=${articleId}`).then(r => r.json()),
    fetch(`/api/qa/accessibility?id=${articleId}`).then(r => r.json()),
    fetch(`/api/qa/images?id=${articleId}`).then(r => r.json()),
    fetch(`/api/qa/seo?id=${articleId}`).then(r => r.json())
  ]);

  const failures = checks.filter(c => !c.passed);

  if (failures.length > 0) {
    return {
      passed: false,
      blockingIssues: failures.map(f => f.message)
    };
  }

  return {passed: true};
}
</script>

• Validation: QA checklist runs on every publish, defect rate tracked monthly, post-publish audits completed within SLA

6. TRO — Training & Onboarding Optimization (new)

• Build structured 30/60/90-day onboarding plan for new hires
• Create role-specific training paths (developer, content writer, SEO specialist, account manager)
• Use video-based training with knowledge checks
• Maintain “shadow program” pairing new hires with experienced team members
• Document client-specific knowledge bases for account-specific onboarding
• Track training completion rates and knowledge retention via quizzes
• Build certification system for internal expertise areas
• Schedule quarterly continuing education based on industry changes

Code Example — Training module page:

<section class="training-module" itemscope itemtype="https://schema.org/Course">
  <h1 itemprop="name">SEO Specialist Onboarding — Module 3: AI Search Optimization</h1>

  <dl>
    <dt>Module Length</dt>
    <dd itemprop="timeRequired">PT4H</dd>
    <dt>Prerequisites</dt>
    <dd>Modules 1 & 2 complete</dd>
  </dl>

  <ol class="lessons">
    <li>Watch: Introduction to AEO/GEO/LLMO (45 min)</li>
    <li>Read: Tier 3 documentation</li>
    <li>Practice: Optimize 3 sample pages for AI extraction</li>
    <li>Quiz: 15 questions, 80% pass rate required</li>
  </ol>

  <button onclick="markComplete()">Mark Module Complete</button>
</section>

• Validation: Onboarding plan documented, average new hire productive in under 30 days, training completion rate above 95%

C. CRM & Customer Communication (2)

7. CRM — CRM Optimization (renamed from CRMo)

• Embed HubSpot, Salesforce, Pipedrive, or Close forms on all lead-generation pages
• Sync website behavior (page views, scroll depth, downloads) to CRM via GTM
• Use bidirectional sync — CRM segment data flows back to website for personalization
• Build dynamic content blocks based on CRM lifecycle stage
• Implement lead scoring rules in CRM that auto-route hot leads to sales
• Maintain clean CRM data hygiene: deduplicate, validate, enrich
• Track CRM activity per lead: emails sent, opens, replies, meetings booked, deals closed
• Build CRM dashboard showing pipeline velocity per source

Code Example — CRM-aware dynamic content:

<section class="dynamic-content" data-crm-personalize>
  <!-- Default content -->
  <div data-lifecycle="lead">
    <h2>New here? Start with our free framework guide</h2>
  </div>

  <!-- Engaged lead content -->
  <div data-lifecycle="mql" hidden>
    <h2>Ready for your free audit?</h2>
  </div>

  <!-- Sales-qualified content -->
  <div data-lifecycle="sql" hidden>
    <h2>Schedule your strategy call with Joseph</h2>
  </div>
</section>

<script>
fetch('/api/crm/contact', {credentials: 'include'})
  .then(r => r.json())
  .then(contact => {
    document.querySelectorAll('[data-lifecycle]').forEach(el => {
      el.hidden = el.dataset.lifecycle !== contact.lifecycle_stage;
    });
  });
</script>

• Validation: CRM sync active and bidirectional, lifecycle-based personalization live, pipeline velocity tracked per source

8. EMK — Email Marketing Optimization (renamed from EMO to avoid Tier 7 conflict)

• Add newsletter signup forms with GDPR-compliant consent in footer + end of articles + dedicated landing pages
• Build lead-magnet-driven email capture (content upgrades per Tier 8 LGO)
• Segment email list by behavior, lifecycle stage, content cluster interest
• Send transactional emails via Postmark/SendGrid for deliverability
• Send marketing emails via Mailchimp, ConvertKit, Beehiiv, or Customer.io
• Use UTM parameters on every email link for attribution tracking
• A/B test subject lines, send times, and content blocks continuously
• Track email metrics: open rate, click rate, unsubscribe rate, revenue per email

Code Example — Email capture form with consent:

<form action="/api/email/subscribe" method="POST" class="email-signup">
  <label for="signup-email">Get weekly AI search insights</label>
  <input type="email" id="signup-email" name="email" required placeholder="[email protected]">

  <label class="consent-label">
    <input type="checkbox" name="consent" required>
    I agree to receive marketing emails. Unsubscribe anytime. <a href="/privacy/">Privacy Policy</a>
  </label>

  <button type="submit">Subscribe Free</button>

  <p class="meta">
    <small>1,200+ subscribers · No spam · Read in browser at <a href="/newsletter/">archive</a></small>
  </p>
</form>

• Validation: List growth above 5% monthly, open rate above 30%, click rate above 3%, GDPR-compliant consent recorded

D. Multi-Channel Outreach (2)

9. SMK — SMS Marketing Optimization (renamed from SMSo)

• Add SMS opt-in forms on checkout, thank-you, and dedicated landing pages with explicit consent
• Use clickable phone numbers with tel: protocol on all contact touchpoints
• Include TCPA-compliant SMS consent language and easy opt-out (reply STOP)
• Build SMS automation flows: appointment reminders, abandoned cart, post-service follow-up
• Use platforms like Twilio, Klaviyo SMS, Attentive, or Postscript
• Track SMS-driven conversions separately from email
• Maintain SMS frequency caps (max 4 per month for marketing, more for transactional)
• Personalize SMS with first name and behavioral context

Code Example — SMS opt-in with TCPA-compliant consent:

<form action="/api/sms/subscribe" method="POST" class="sms-signup">
  <label for="sms-phone">Get text alerts for AI search updates</label>
  <input type="tel" id="sms-phone" name="phone" required placeholder="(555) 123-4567">

  <label class="consent-label">
    <input type="checkbox" name="tcpa_consent" required>
    By checking this box, you agree to receive automated marketing text messages from
    ThatDeveloperGuy at the phone number provided. Consent is not a condition of purchase.
    Msg & data rates may apply. Reply STOP to unsubscribe. View our
    <a href="/privacy/">Privacy Policy</a> and <a href="/terms/">Terms</a>.
  </label>

  <button type="submit">Subscribe to SMS</button>
</form>

<a href="tel:+15055123662" class="phone-cta">
  📞 (505) 512-3662
</a>

• Validation: TCPA-compliant consent recorded, opt-out rate below 5%, SMS-driven revenue tracked

10. PNO — Push Notification Optimization

• Implement web push notifications via OneSignal, Firebase Cloud Messaging, or Pushwoosh
• Trigger subscribe prompt on second visit (not first) to avoid annoying first-time visitors
• Segment subscribers by behavior: content interests, lifecycle stage, last visit date
• Build automated push flows: new content alerts, abandoned cart, re-engagement campaigns
• Personalize push content based on subscriber segment
• Test push timing — most opens happen within 1 hour of send
• Track push metrics: delivery rate, open rate, click-through rate, conversion rate
• Provide easy opt-out and respect user preferences

Code Example — Push notification opt-in:

<script>
// Trigger subscribe prompt on second visit only
const visits = parseInt(localStorage.getItem('visit_count') || '0') + 1;
localStorage.setItem('visit_count', visits);

if (visits === 2 && 'Notification' in window && Notification.permission === 'default') {
  // Show custom prompt before browser prompt (better UX)
  showCustomPushPrompt({
    onAccept: async () => {
      const permission = await Notification.requestPermission();
      if (permission === 'granted') {
        // Subscribe via OneSignal/Firebase
        await subscribeToPush();

        window.dataLayer.push({
          'event': 'push_subscribed',
          'visit_number': visits
        });
      }
    }
  });
}
</script>

• Validation: Push subscription rate above 5%, segmented push campaigns active, conversion rate from push tracked

Summary

• Total items: 10
• Sub-clusters: 4 (Automation & AI-Assisted Operations, Documentation & Quality, CRM & Customer Communication, Multi-Channel Outreach)
• Format: Each item includes 7–8 implementation steps, a code example, and a validation criterion
• Net change from original: 0 dropped, 4 added (AIW, DOC, QAO, TRO), 4 acronym conflicts resolved (CRMo → CRM, PRO → PRP, EMO → EMK, SMSo → SMK)
• Position in stack: Operational backbone — depends on Tiers 1–9, makes everything else scalable and repeatable

About this series

This is one of 14 articles in ThatDevPro’s Engine Optimization stack — a productized SEO + AEO + AIO + GEO service. Each tier is a self-contained framework with concrete checklists, validation steps, and code patterns.

Canonical source for this article: https://www.thatdevpro.com/insights/seo-tier-10-workflow-and-operations/

The 14-tier series:

1. Tier 1 — Foundation
2. Tier 2 — Search Visibility
3. Tier 3 — AI Domination
4. Tier 4 — Entity and Authority
5. Tier 5 — Local Domination
6. Tier 6 — Content and Multimedia
7. Tier 7 — Social and Community
8. Tier 8 — Data, Analytics, Conversion
9. Tier 9 — Monitoring and Intelligence
10. Tier 10 — Workflow and Operations
11. Tier 11 — Marketplace and Retail
12. Tier 12 — International
13. Tier 14 — Advanced and Immersive

Tier 13 is retired.

Need this implemented on your site? ThatDevPro ships the full 14-tier stack as a productized service. SDVOSB-certified veteran-owned. Cassville, Missouri. See the Engine Optimization service.

Open-source tooling powering this series:

• aio-surfaces — Python toolkit (MIT) for generating llms.txt + aeo.json + entity.json + brand.json
• llms.txt generator — live Hugging Face Space

Originally published at thatdevpro.com. This article 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 republish; the canonical source is on ThatDevPro.com. Source repo for the AI-citation surfaces: github.com/Janady13/aio-surfaces.

Tier Explanation: Dominates third-party sales channels where buyers increasingly search and purchase. In 2026, rich product schema, fast feeds, omnichannel consistency, and marketplace-specific optimization are essential for visibility and conversion. All actions execute on website product pages, schema, feeds, and marketplace integrations. Tiers 1–10 must be in place first.

Related Frameworks

This tier implements the following framework documents in the /Framework/ library. Consult them for canonical reference, audit rubrics, and detailed implementation patterns.

• framework-ecommerceseo.md — Product schema, faceted nav, MerchantReturnPolicy
• framework-schema.md — Product, Offer, AggregateRating, Brand
• framework-shopify.md — Shopify-specific patterns
• framework-imageseo.md — Product image optimization
• framework-cro.md — Conversion overlay on product / category pages

A. Marketplace Platforms (4)

1. AMO — Amazon & Marketplace Optimization

• Build dedicated product landing pages on owned domain mirroring Amazon listings
• Sync inventory, pricing, and availability via Amazon Selling Partner API
• Add “Buy on Amazon” CTAs with proper affiliate/tracking parameters
• Use Amazon Brand Registry for trademark protection and A+ Content access
• Optimize Amazon listings with backend keywords, A+ Content, and enhanced brand content
• Pursue Amazon Vine reviews and Amazon’s Choice badge eligibility
• Build comparison pages: “Buy on Amazon vs Buy Direct” with pricing transparency
• Track Amazon-driven traffic and revenue separately for ROI analysis

Code Example — On-site Amazon product mirror:

<article class="product-page" itemscope itemtype="https://schema.org/Product">
  <h1 itemprop="name">14-Tier Engine Optimization Audit</h1>
  <img src="/products/audit.jpg" alt="14-Tier Audit" itemprop="image">

  <div itemprop="offers" itemscope itemtype="https://schema.org/AggregateOffer">
    <p>Available from <span itemprop="offerCount">3</span> sellers, starting at
       $<span itemprop="lowPrice">997</span></p>
  </div>

  <div class="purchase-options">
    <a href="/checkout/audit/" class="btn-primary">Buy Direct ($997)</a>
    <a href="https://amazon.com/dp/B0XXXXXX?tag=thatdevguy-20"
       rel="noopener sponsored"
       class="btn-amazon">
      Buy on Amazon ($1,047)
    </a>
  </div>
</article>

• Validation: Product mirror pages live, Amazon listings optimized with A+ Content, Amazon-driven revenue tracked monthly

2. ASO — App Store Optimization

• Build dedicated app landing pages with keyword-rich descriptions, screenshots, and feature lists
• Add MobileApplication schema with app store deep links
• Include “Download on App Store” and “Get on Google Play” badges with direct links
• Optimize app store listings: keyword-rich title, subtitle, description, screenshots
• Pursue app reviews via in-app prompts at moments of peak satisfaction
• Use App Store Connect and Google Play Console analytics for conversion tracking
• Run paid Apple Search Ads and Google App Campaigns for category visibility
• Build “What’s New” content for every app update

Code Example — App landing page with schema:

<article class="app-landing" itemscope itemtype="https://schema.org/MobileApplication">
  <h1 itemprop="name">14-Tier Audit Mobile</h1>
  <p itemprop="description">Run AI search audits from your phone. Free for the first 5 audits.</p>

  <meta itemprop="operatingSystem" content="iOS, Android">
  <meta itemprop="applicationCategory" content="BusinessApplication">

  <div itemprop="aggregateRating" itemscope itemtype="https://schema.org/AggregateRating">
    <span itemprop="ratingValue">4.8</span>/5
    (<span itemprop="ratingCount">237</span> reviews)
  </div>

  <div class="app-store-badges">
    <a href="https://apps.apple.com/app/id123456789" rel="noopener">
      <img src="/badges/app-store.svg" alt="Download on the App Store" width="180" height="60">
    </a>
    <a href="https://play.google.com/store/apps/details?id=com.thatdeveloperguy" rel="noopener">
      <img src="/badges/google-play.svg" alt="Get it on Google Play" width="180" height="60">
    </a>
  </div>
</article>

• Validation: MobileApplication schema validates, app store conversion rate tracked, app reviews above 4.5 stars

3. MPO — Marketplace Platform Optimization (consolidates Etsy + eBay + Walmart)

Etsy-specific: Optimize listings for handmade/vintage search intent with descriptive keyword-rich titles, 13 tags utilized, high-quality lifestyle photos, and Etsy SEO-friendly descriptions

eBay-specific: Use eBay’s catalog system, optimize for “Buy It Now” intent, leverage eBay Promoted Listings, maintain seller rating above 99%

Walmart-specific: Sync product data via Walmart Marketplace API, use GTIN/MPN attributes, pursue Walmart Pro Seller badge, optimize for two-day shipping eligibility

Universal marketplace tactics:

• Sync product catalog across all marketplaces via central PIM (Product Information Management)
• Maintain consistent pricing across marketplaces (or strategic differentiation with reasoning)
• Build per-marketplace landing pages on owned domain for SEO traffic + conversion routing
• Track per-marketplace metrics: revenue, conversion rate, return rate, review velocity
• Pursue platform-specific badges and seller status (Top Rated, Pro Seller, Star Seller)

Code Example — Multi-marketplace product page:

<section class="marketplace-options">
  <h2>Buy From Your Preferred Marketplace</h2>

  <div class="marketplace-grid">
    <a href="https://etsy.com/listing/123456" rel="noopener" class="marketplace-card">
      <img src="/badges/etsy.svg" alt="Etsy">
      <p>$24.99 + free shipping</p>
      <small>★★★★★ (487 reviews)</small>
    </a>

    <a href="https://ebay.com/itm/123456" rel="noopener" class="marketplace-card">
      <img src="/badges/ebay.svg" alt="eBay">
      <p>$22.99 Buy It Now</p>
      <small>★★★★★ (1,247 reviews)</small>
    </a>

    <a href="https://walmart.com/ip/123456" rel="noopener" class="marketplace-card">
      <img src="/badges/walmart.svg" alt="Walmart">
      <p>$23.99 + 2-day shipping</p>
      <small>★★★★★ (89 reviews)</small>
    </a>
  </div>
</section>

• Validation: Active listings on 3+ marketplaces, per-marketplace metrics tracked, seller status above platform threshold

4. SHO — Shopify Optimization (renamed from Shopify SEO)

• Optimize Shopify theme for Core Web Vitals (most stock themes need significant work)
• Use Shopify SEO apps: Smart SEO, SEOAnt, JSON-LD for SEO, Avada SEO Suite
• Configure proper meta tags, schema, and sitemaps via apps or theme.liquid
• Optimize collection pages with keyword-rich descriptions and CollectionPage schema
• Use Shopify’s native blog with proper Article schema for content marketing
• Implement faceted navigation correctly to avoid index bloat from filter URLs
• Set up Shopify Analytics + GA4 + Meta Pixel for full conversion tracking
• Use Shopify Markets for international expansion with proper hreflang

Code Example — Shopify product page enhancement:

{% comment %} In Shopify product.liquid template {% endcomment %}
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "{{ product.title | escape }}",
  "image": "{{ product.featured_image | img_url: '1024x1024' | prepend: 'https:' }}",
  "description": "{{ product.description | strip_html | truncate: 200 | escape }}",
  "sku": "{{ product.selected_or_first_available_variant.sku }}",
  "brand": {
    "@type": "Brand",
    "name": "{{ product.vendor | escape }}"
  },
  "offers": {
    "@type": "Offer",
    "url": "{{ shop.url }}{{ product.url }}",
    "priceCurrency": "{{ shop.currency }}",
    "price": "{{ product.price | money_without_currency | replace: ',', '' }}",
    "availability": "{% if product.available %}https://schema.org/InStock{% else %}https://schema.org/OutOfStock{% endif %}"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "{{ product.metafields.reviews.rating }}",
    "reviewCount": "{{ product.metafields.reviews.count }}"
  }
}
</script>

• Validation: All Shopify products have valid Product schema, Core Web Vitals “Good” rating, proper canonical handling on collection pages

B. Product Data & Listings (3)

5. PDO — Product Data Optimization (renamed from Product Listing Optimization)

• Add complete Product schema (name, price, availability, review, offer, brand, sku, gtin, mpn) on every product page
• Include high-quality images (multiple angles, lifestyle, detail shots) with descriptive alt text
• Use ImageObject schema with creator, license, caption for product imagery
• Maintain detailed product specifications in structured format (size, weight, materials, dimensions)
• Build comparison-ready product attribute schema for cross-product analysis
• Display warranty, return policy, and shipping info via OfferShippingDetails and MerchantReturnPolicy schema
• Add HowTo schema for product setup or usage where applicable
• Include video content with VideoObject schema demonstrating product

Code Example — Comprehensive Product schema:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "14-Tier Engine Optimization Audit",
  "image": [
    "https://thatdeveloperguy.com/products/audit-1.jpg",
    "https://thatdeveloperguy.com/products/audit-2.jpg"
  ],
  "description": "Comprehensive audit of all 178+ optimizations across your website.",
  "sku": "AUDIT-14T",
  "mpn": "TDG-AUDIT-2026",
  "brand": {
    "@type": "Brand",
    "name": "ThatDeveloperGuy"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://thatdeveloperguy.com/products/audit/",
    "priceCurrency": "USD",
    "price": "997",
    "priceValidUntil": "2026-12-31",
    "availability": "https://schema.org/InStock",
    "seller": {
      "@type": "Organization",
      "name": "ThatDeveloperGuy"
    },
    "shippingDetails": {
      "@type": "OfferShippingDetails",
      "shippingRate": {
        "@type": "MonetaryAmount",
        "value": "0",
        "currency": "USD"
      },
      "deliveryTime": {
        "@type": "ShippingDeliveryTime",
        "businessDays": {
          "@type": "OpeningHoursSpecification",
          "dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
        },
        "transitTime": {
          "@type": "QuantitativeValue",
          "minValue": 0,
          "maxValue": 1,
          "unitCode": "DAY"
        }
      }
    },
    "hasMerchantReturnPolicy": {
      "@type": "MerchantReturnPolicy",
      "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
      "merchantReturnDays": 30,
      "returnMethod": "https://schema.org/ReturnByMail",
      "returnFees": "https://schema.org/FreeReturn"
    }
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.9",
    "reviewCount": "127"
  }
}
</script>

• Validation: Product schema validates with zero errors, rich results display in SERP, all schema fields populated

6. SFD — Shopping Feed Data (renamed from Shopping Feed Optimization)

• Generate dynamic product feeds for Google Merchant Center, Meta Catalog, Microsoft Merchant Center
• Include all required attributes: id, title, description, link, image_link, price, availability, brand, gtin, mpn
• Use rich attributes for better matching: condition, color, size, gender, age_group, material
• Add shipping and tax attributes per region for accurate shopping ad display
• Update feeds at minimum daily — pricing and availability changes need fast propagation
• Validate feeds via Merchant Center diagnostics before submission
• Build automated feed generation tied to inventory system
• Track feed health: approval rate, disapproval reasons, performance per attribute

Code Example — Google Merchant Feed XML structure:

<rss xmlns:g="http://base.google.com/ns/1.0" version="2.0">
  <channel>
    <title>ThatDeveloperGuy Product Catalog</title>
    <link>https://thatdeveloperguy.com</link>
    <description>Engine Optimization Services</description>

    <item>
      <g:id>AUDIT-14T</g:id>
      <g:title>14-Tier Engine Optimization Audit</g:title>
      <g:description>Comprehensive audit of all 178+ optimizations</g:description>
      <g:link>https://thatdeveloperguy.com/products/audit/</g:link>
      <g:image_link>https://thatdeveloperguy.com/products/audit.jpg</g:image_link>
      <g:price>997.00 USD</g:price>
      <g:availability>in_stock</g:availability>
      <g:brand>ThatDeveloperGuy</g:brand>
      <g:condition>new</g:condition>
      <g:gtin>00012345678905</g:gtin>
      <g:mpn>TDG-AUDIT-2026</g:mpn>
      <g:google_product_category>Business &amp; Industrial &gt; Advertising &amp; Marketing</g:google_product_category>
      <g:shipping>
        <g:country>US</g:country>
        <g:service>Standard</g:service>
        <g:price>0 USD</g:price>
      </g:shipping>
    </item>
  </channel>
</rss>

• Validation: Feed approved in Merchant Center with zero errors, daily refresh active, all required attributes populated

7. RRO — Rich Results Optimization

• Implement Product, Offer, Review, AggregateRating, FAQ, HowTo schema where applicable
• Test every page with Google Rich Results Test before launch
• Monitor Rich Results Status report in GSC for errors and warnings
• Use breadcrumb schema on every product page for navigation rich results
• Add Review schema for products with verified user reviews
• Pursue eligibility for additional rich result types: Recipe, Event, Course, Job Posting (where applicable to business)
• Track rich result CTR vs standard SERP CTR — rich results typically lift CTR 20-40%
• Update schema as Google rolls out new rich result types

Code Example — Multi-schema rich results:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Product",
      "@id": "#product",
      "name": "14-Tier Audit"
    },
    {
      "@type": "BreadcrumbList",
      "itemListElement": [
        {"@type": "ListItem", "position": 1, "name": "Home", "item": "https://thatdeveloperguy.com"},
        {"@type": "ListItem", "position": 2, "name": "Products", "item": "https://thatdeveloperguy.com/products/"},
        {"@type": "ListItem", "position": 3, "name": "14-Tier Audit"}
      ]
    },
    {
      "@type": "FAQPage",
      "mainEntity": [{
        "@type": "Question",
        "name": "What's included in the 14-Tier Audit?",
        "acceptedAnswer": {
          "@type": "Answer",
          "text": "Comprehensive analysis across all 178 optimizations..."
        }
      }]
    }
  ]
}
</script>

• Validation: Rich Results Test passes for all schemas, GSC shows zero schema errors, rich result CTR exceeds standard CTR

C. Conversion & Trust (3)

8. COC — Comparison & Conversion Optimization (new)

• Build “[Product] vs [Competitor]” comparison pages capturing high-intent commercial queries
• Use comparison tables with structured data showing factual differentiators
• Include side-by-side pricing, features, and use case matching
• Add “Best for [Use Case]” guidance helping users self-select
• Build “Alternatives to [Competitor]” pages targeting competitor brand searches
• Include verifiable benchmarks, data, and case study links
• Add “Why we built this” narrative explaining unique value proposition
• Track comparison page conversion rate vs standard product pages

Code Example — Comparison schema:

<table class="comparison-table" itemscope itemtype="https://schema.org/Table">
  <caption>14-Tier Audit vs Generic SEO Audit</caption>
  <thead>
    <tr><th>Feature</th><th>14-Tier Audit</th><th>Generic SEO Audit</th></tr>
  </thead>
  <tbody>
    <tr><td>Items audited</td><td>178+</td><td>~50</td></tr>
    <tr><td>AI search optimization</td><td>✓ Tier 3</td><td>✗ Not included</td></tr>
    <tr><td>Code examples per item</td><td>✓ Yes</td><td>✗ No</td></tr>
    <tr><td>Validation criteria</td><td>✓ Per item</td><td>✗ Not specified</td></tr>
    <tr><td>Price</td><td>$997</td><td>$497-2,500</td></tr>
  </tbody>
</table>

• Validation: 5+ comparison pages live, comparison pages convert above 3x standard product pages, capture commercial intent traffic

9. AVO — Availability Optimization (new)

• Maintain real-time inventory accuracy across all sales channels
• Use availability schema (InStock, OutOfStock, PreOrder, BackOrder) accurately
• Build low-stock urgency indicators (when inventory is genuinely low — no fake scarcity)
• Implement waitlist functionality for out-of-stock products
• Use priceValidUntil to show pricing legitimacy and prevent stale listings
• Set up automated low-inventory alerts for procurement and ad spend adjustments
• Display estimated restock dates when out of stock
• Track stockout impact on conversion and adjust inventory planning

Code Example — Real-time availability with waitlist:

<section class="product-availability" data-product-id="AUDIT-14T">
  <div class="availability-status" data-status="in_stock">
    <span class="status-indicator"></span>
    <strong>In Stock</strong>
    <small>237 audits delivered this month</small>
  </div>

  <!-- Hidden until status changes -->
  <div class="availability-status" data-status="low_stock" hidden>
    <span class="status-indicator low"></span>
    <strong>Limited Availability</strong>
    <small>Only 3 audit slots remaining this month</small>
  </div>

  <div class="availability-status" data-status="out_of_stock" hidden>
    <span class="status-indicator out"></span>
    <strong>Fully Booked This Month</strong>
    <small>Next availability: May 15, 2026</small>
    <form action="/api/waitlist/join" method="POST">
      <input type="email" name="email" required placeholder="Join waitlist">
      <button type="submit">Notify Me</button>
    </form>
  </div>
</section>

<script>
fetch('/api/availability/AUDIT-14T')
  .then(r => r.json())
  .then(data => {
    document.querySelectorAll('[data-status]').forEach(el => {
      el.hidden = el.dataset.status !== data.status;
    });
  });
</script>

• Validation: Inventory accuracy above 98% across channels, waitlist active for OOS products, stockout impact tracked

10. RTO — Returns & Trust Optimization (new)

• Display clear return policy with MerchantReturnPolicy schema on every product page
• Offer free returns where economically feasible (lifts conversion 15-25%)
• Show trust badges from verified third parties: BBB, Trustpilot, McAfee Secure, Norton Secured
• Display real-time security indicators: SSL badge, payment processor logos, money-back guarantee
• Add “Protected by” badges from genuine certification providers
• Include detailed FAQ section addressing common pre-purchase concerns
• Display real customer photos and verified review count prominently
• Implement easy returns process with self-service portal

Code Example — Trust signals + return policy schema:

<section class="trust-signals">
  <div class="guarantee">
    <h3>30-Day Money-Back Guarantee</h3>
    <p>Not satisfied? Full refund, no questions asked.</p>
  </div>

  <div class="security-badges">
    <img src="/badges/bbb-a-plus.svg" alt="BBB Accredited Business A+ rating" width="80">
    <img src="/badges/trustpilot-excellent.svg" alt="Trustpilot Excellent rating" width="80">
    <img src="/badges/ssl-secured.svg" alt="SSL Secured Connection" width="80">
  </div>
</section>

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "MerchantReturnPolicy",
  "applicableCountry": "US",
  "returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
  "merchantReturnDays": 30,
  "returnMethod": "https://schema.org/ReturnByMail",
  "returnFees": "https://schema.org/FreeReturn",
  "refundType": "https://schema.org/FullRefund"
}
</script>

• Validation: Return policy schema on every product, conversion lift from trust signals tracked, return rate within industry norms

Summary

• Total items: 10
• Sub-clusters: 3 (Marketplace Platforms, Product Data & Listings, Conversion & Trust)
• Format: Each item includes 7–8 implementation steps, a code example, and a validation criterion
• Net change from original: 3 platform-specific items consolidated into MPO, 3 added (COC, AVO, RTO), 3 renamed for consistent codes
• Position in stack: Commerce tier — depends on Tiers 1–10, optimizes the entire sales channel ecosystem beyond owned site

About this series

This is one of 14 articles in ThatDevPro’s Engine Optimization stack — a productized SEO + AEO + AIO + GEO service. Each tier is a self-contained framework with concrete checklists, validation steps, and code patterns.

Canonical source for this article: https://www.thatdevpro.com/insights/seo-tier-11-marketplace-and-retail/

The 14-tier series:

1. Tier 1 — Foundation
2. Tier 2 — Search Visibility
3. Tier 3 — AI Domination
4. Tier 4 — Entity and Authority
5. Tier 5 — Local Domination
6. Tier 6 — Content and Multimedia
7. Tier 7 — Social and Community
8. Tier 8 — Data, Analytics, Conversion
9. Tier 9 — Monitoring and Intelligence
10. Tier 10 — Workflow and Operations
11. Tier 11 — Marketplace and Retail
12. Tier 12 — International
13. Tier 14 — Advanced and Immersive

Tier 13 is retired.

Need this implemented on your site? ThatDevPro ships the full 14-tier stack as a productized service. SDVOSB-certified veteran-owned. Cassville, Missouri. See the Engine Optimization service.

Open-source tooling powering this series:

• aio-surfaces — Python toolkit (MIT) for generating llms.txt + aeo.json + entity.json + brand.json
• llms.txt generator — live Hugging Face Space

Originally published at thatdevpro.com. This article 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 republish; the canonical source is on ThatDevPro.com. Source repo for the AI-citation surfaces: github.com/Janady13/aio-surfaces.

Tier Explanation: Enables global scaling while preserving local relevance and authority. In 2026, hreflang correctness, ccTLD/subdomain strategy, currency localization, cultural adaptation, and country-specific entity signals are required for international visibility. AI engines also weight regional authority signals heavily. All actions execute on website templates, schema, sitemaps, and supporting infrastructure. Tiers 1–11 must be in place first.

Related Frameworks

This tier implements the following framework documents in the /Framework/ library. Consult them for canonical reference, audit rubrics, and detailed implementation patterns.

• framework-international.md — hreflang, ccTLD vs subfolder, multilingual content
• framework-technicalseo.md — hreflang implementation in sitemap or HTTP headers
• framework-localseo.md — Per-region GBP and citations if multi-country presence

A. International Foundation (3)

1. IPO — International Page Optimization

• Create country-specific page versions with localized content, currency, and cultural references
• Use proper hreflang tags in <head> of every internationalized page
• Maintain consistent URL structure: /en-us/, /en-gb/, /es-mx/, /de-de/
• Add country/language switcher in header — never auto-redirect based on IP (hurts UX and crawling)
• Localize all metadata: title tags, meta descriptions, Open Graph, Twitter Cards
• Use country-appropriate imagery, not generic stock photos that read as foreign
• Include local phone numbers, addresses, and business hours per region
• Track regional traffic and conversion separately to inform localization investment

Code Example — Internationalized page with country switcher:

<head>
  <link rel="alternate" hreflang="en-us" href="https://thatdeveloperguy.com/en-us/" />
  <link rel="alternate" hreflang="en-gb" href="https://thatdeveloperguy.com/en-gb/" />
  <link rel="alternate" hreflang="es-mx" href="https://thatdeveloperguy.com/es-mx/" />
  <link rel="alternate" hreflang="x-default" href="https://thatdeveloperguy.com/" />
  <meta name="language" content="en-US">
</head>

<header>
  <nav class="region-switcher" aria-label="Choose your region">
    <button id="region-toggle" aria-expanded="false">🌐 United States (English)</button>
    <ul id="region-list" hidden>
      <li><a href="/en-us/" hreflang="en-us">🇺🇸 United States (English)</a></li>
      <li><a href="/en-gb/" hreflang="en-gb">🇬🇧 United Kingdom (English)</a></li>
      <li><a href="/en-ca/" hreflang="en-ca">🇨🇦 Canada (English)</a></li>
      <li><a href="/es-mx/" hreflang="es-mx">🇲🇽 México (Español)</a></li>
      <li><a href="/de-de/" hreflang="de-de">🇩🇪 Deutschland (Deutsch)</a></li>
    </ul>
  </nav>
</header>

• Validation: Hreflang validates with zero errors in GSC, region switcher prominent in header, regional traffic tracked separately

2. MLO — Multilingual Optimization (renamed from Multilingual SEO)

• Use professional human translators for primary content — avoid pure machine translation
• Build separate URL paths per language (/en/, /es/, /fr/) — never use cookie-based language switching only
• Add lang attribute on <html> and use lang attribute on inline elements with mixed languages
• Translate all UI elements: buttons, forms, error messages, alt text
• Localize date formats, number formats, and units of measurement
• Adapt content for cultural context, not just translation (idioms, examples, references)
• Build language-specific FAQ sections addressing region-specific questions
• Track per-language SEO metrics: rankings, traffic, conversions

Code Example — Multi-language content with proper lang attributes:

<html lang="en-US">
<head>
  <title>14-Tier AI Search Optimization Framework</title>
</head>
<body>
  <article>
    <h1>The Complete Framework</h1>
    <p>Used by businesses worldwide to dominate AI search results.</p>

    <blockquote lang="es-MX">
      <p>"El marco más completo que hemos implementado." — Cliente en CDMX</p>
    </blockquote>

    <blockquote lang="de-DE">
      <p>"Das umfassendste Framework, das wir je gesehen haben." — Klient in Berlin</p>
    </blockquote>
  </article>
</body>
</html>

• Validation: Professional translations on all primary content, lang attributes correct sitewide, per-language metrics tracked

3. ISC — International Schema (renamed from International Schema)

• Add localized Organization and LocalBusiness schema per country office or operating region
• Use inLanguage property on Article and WebPage schema to declare content language
• Add currency-specific pricing in Product schema with priceCurrency (ISO 4217)
• Use addressCountry with ISO 3166-1 alpha-2 codes consistently
• Build per-country Person schema with localized credentials and nationality
• Add availableLanguage to Service schema for multilingual service offerings
• Use proper region codes in geo-targeting: addressRegion follows local conventions
• Validate schema across all locale variants — translation errors break schema parsing

Code Example — Multi-region Organization schema:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://thatdeveloperguy.com/#organization",
      "name": "ThatDeveloperGuy",
      "url": "https://thatdeveloperguy.com",
      "subOrganization": [
        {
          "@type": "LocalBusiness",
          "@id": "https://thatdeveloperguy.com/locations/us/#localbusiness",
          "name": "ThatDeveloperGuy USA",
          "address": {
            "@type": "PostalAddress",
            "streetAddress": "463 State Highway 76",
            "addressLocality": "Cassville",
            "addressRegion": "MO",
            "postalCode": "65625",
            "addressCountry": "US"
          },
          "availableLanguage": ["en-US", "es-MX"],
          "priceRange": "$$",
          "currenciesAccepted": "USD"
        },
        {
          "@type": "LocalBusiness",
          "@id": "https://thatdeveloperguy.com/locations/uk/#localbusiness",
          "name": "ThatDeveloperGuy UK",
          "address": {
            "@type": "PostalAddress",
            "addressLocality": "London",
            "addressCountry": "GB"
          },
          "availableLanguage": ["en-GB"],
          "currenciesAccepted": "GBP"
        }
      ]
    }
  ]
}
</script>

• Validation: Per-country schema validates, currency codes correct, availableLanguage matches actual support

B. Geographic & Domain Strategy (3)

4. ISM — International Sitemap (renamed)

• Generate separate sitemaps per language/country variant
• Build sitemap index file referencing all regional sitemaps
• Submit each regional sitemap individually in GSC and Bing Webmaster Tools
• Include hreflang annotations within sitemaps as alternate URLs
• Update sitemaps automatically when content publishes or updates per region
• Use <lastmod> accurately per regional version (translation update changes lastmod)
• Validate sitemap XML structure before submission
• Monitor sitemap indexation rate per region — submit fresh sitemaps when crawl errors appear

Code Example — Sitemap index with regional sitemaps:

<?xml version="1.0" encoding="UTF-8"?>
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <sitemap>
    <loc>https://thatdeveloperguy.com/sitemap-en-us.xml</loc>
    <lastmod>2026-04-29</lastmod>
  </sitemap>
  <sitemap>
    <loc>https://thatdeveloperguy.com/sitemap-en-gb.xml</loc>
    <lastmod>2026-04-29</lastmod>
  </sitemap>
  <sitemap>
    <loc>https://thatdeveloperguy.com/sitemap-es-mx.xml</loc>
    <lastmod>2026-04-29</lastmod>
  </sitemap>
  <sitemap>
    <loc>https://thatdeveloperguy.com/sitemap-de-de.xml</loc>
    <lastmod>2026-04-29</lastmod>
  </sitemap>
</sitemapindex>

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
        xmlns:xhtml="http://www.w3.org/1999/xhtml">
  <url>
    <loc>https://thatdeveloperguy.com/en-us/services/audit/</loc>
    <xhtml:link rel="alternate" hreflang="en-us" href="https://thatdeveloperguy.com/en-us/services/audit/"/>
    <xhtml:link rel="alternate" hreflang="en-gb" href="https://thatdeveloperguy.com/en-gb/services/audit/"/>
    <xhtml:link rel="alternate" hreflang="es-mx" href="https://thatdeveloperguy.com/es-mx/services/audit/"/>
    <xhtml:link rel="alternate" hreflang="x-default" href="https://thatdeveloperguy.com/services/audit/"/>
    <lastmod>2026-04-29</lastmod>
  </url>
</urlset>

• Validation: All regional sitemaps submitted and indexed, hreflang annotations within sitemaps validate, indexation rate above 90% per region

5. CCD — Country Code Domain Strategy (renamed)

• Choose between ccTLD (.co.uk, .de), subdirectory (/uk/, /de/), or subdomain (uk., de.) based on:
  • ccTLDs: Strongest geo-targeting, separate authority per domain, expensive to manage at scale
  • Subdirectories: Easiest to manage, shared authority, requires manual GSC geo-targeting
  • Subdomains: Middle ground, treated as separate sites by Google
• Set proper geotargeting in GSC for subdirectory or subdomain strategy
• Maintain consistent NAP and entity signals across regional variants
• Build separate GSC and analytics properties per regional domain/path
• Localize backlink building per region — UK links matter for .co.uk, German links for .de
• Avoid duplicate content across regions via proper canonical and hreflang strategy
• Document domain strategy decision rationale for team alignment

Code Example — Subdirectory strategy with GSC verification:

<!-- All variants verified in GSC, geotargeting set per subdirectory -->
<!-- /en-us/ → United States targeting -->
<!-- /en-gb/ → United Kingdom targeting -->
<!-- /de-de/ → Germany targeting -->

<!-- Canonical points to language-specific URL -->
<link rel="canonical" href="https://thatdeveloperguy.com/en-gb/services/audit/" />

<!-- Hreflang lists all alternates -->
<link rel="alternate" hreflang="en-us" href="https://thatdeveloperguy.com/en-us/services/audit/" />
<link rel="alternate" hreflang="en-gb" href="https://thatdeveloperguy.com/en-gb/services/audit/" />
<link rel="alternate" hreflang="de-de" href="https://thatdeveloperguy.com/de-de/services/audit/" />
<link rel="alternate" hreflang="x-default" href="https://thatdeveloperguy.com/services/audit/" />

• Validation: Domain strategy documented, GSC geo-targeting set per region, regional GSC properties verified, no duplicate content flags

6. GTR — Geotargeting (new)

• Use server-side geo-IP detection only as a hint — display banner offering localized version, never force redirect
• Honor user’s manual region selection via cookie that overrides geo-IP
• Use Cloudflare or similar CDN’s geo-routing for performance, not content selection
• Build region-specific landing pages targeting “[service] in [country/region]” queries
• Use Place schema with containedInPlace to declare regional service availability
• Track geo-IP accuracy — VPN users and travelers can throw off targeting
• Test geo-targeting from multiple regions using VPN or services like BrowserStack
• Monitor regional rankings via location-aware rank tracking tools

Code Example — Soft geo-suggestion banner:

<aside id="region-suggestion" class="region-banner" hidden>
  <p>
    👋 It looks like you're visiting from the <strong id="detected-country">United Kingdom</strong>.
    Would you like to view our <a href="/en-gb/" id="suggested-region-link">UK site</a> with GBP pricing?
  </p>
  <button onclick="dismissRegionSuggestion()">Stay on US Site</button>
  <button onclick="acceptRegionSuggestion()">Yes, Switch to UK</button>
</aside>

<script>
async function checkRegion() {
  // Don't show if user already chose a region
  if (localStorage.getItem('region_preference')) return;

  const geo = await fetch('/api/geo/detect').then(r => r.json());
  const currentPath = window.location.pathname;

  // Only suggest if user is on different region's site
  if (geo.suggested_path && !currentPath.startsWith(geo.suggested_path)) {
    document.getElementById('detected-country').textContent = geo.country_name;
    document.getElementById('suggested-region-link').href = geo.suggested_path;
    document.getElementById('region-suggestion').hidden = false;
  }
}

function dismissRegionSuggestion() {
  localStorage.setItem('region_preference', 'stay');
  document.getElementById('region-suggestion').hidden = true;
}

function acceptRegionSuggestion() {
  localStorage.setItem('region_preference', 'auto');
  window.location.href = document.getElementById('suggested-region-link').href;
}

checkRegion();
</script>

• Validation: Soft suggestions never force redirects, user region preferences honored, geo-targeting accuracy tested from 5+ regions

C. Localization & Cultural (2)

7. CUL — Currency & Localization (new)

• Display prices in user’s local currency with accurate real-time conversion
• Use proper currency symbols, decimal separators, and number formats per locale
• Localize date formats: MM/DD/YYYY (US), DD/MM/YYYY (UK/EU), YYYY-MM-DD (ISO/Asia)
• Adapt units of measurement: imperial vs metric, gallons vs liters, miles vs kilometers
• Localize phone number formats with proper country codes (+1 vs +44 vs +49)
• Adapt time zones in event listings, business hours, and webinar schedules
• Handle right-to-left languages (Arabic, Hebrew) with proper dir="rtl" attribute
• Localize legal pages per regional requirements (GDPR, CCPA, UK Data Protection Act)

Code Example — Localized pricing display:

<section class="pricing-block" data-product="audit">
  <h2>14-Tier Audit</h2>
  <p class="price" id="localized-price">$997 USD</p>
  <p class="local-equivalent" id="local-equivalent" hidden></p>

  <button class="btn-primary">Buy Now</button>
</section>

<script>
const priceUSD = 997;
const userLocale = navigator.language || 'en-US';
const userRegion = userLocale.split('-')[1] || 'US';

const currencyMap = {
  'GB': {currency: 'GBP', rate: 0.79, symbol: '£'},
  'CA': {currency: 'CAD', rate: 1.35, symbol: 'C$'},
  'MX': {currency: 'MXN', rate: 17.5, symbol: 'MX$'},
  'DE': {currency: 'EUR', rate: 0.92, symbol: '€'}
};

if (currencyMap[userRegion]) {
  const localCurrency = currencyMap[userRegion];
  const localPrice = (priceUSD * localCurrency.rate).toFixed(2);

  document.getElementById('local-equivalent').textContent =
    `≈ ${localCurrency.symbol}${localPrice} ${localCurrency.currency}`;
  document.getElementById('local-equivalent').hidden = false;
}

// Format using Intl
const formatter = new Intl.NumberFormat(userLocale, {
  style: 'currency',
  currency: 'USD'
});
document.getElementById('localized-price').textContent = formatter.format(priceUSD) + ' USD';
</script>

• Validation: Currency conversions accurate within 1%, number/date formats match locale conventions, RTL support tested if applicable

8. TCM — Translation & Cultural Management (new)

• Hire native-speaker translators or use professional translation services (Smartling, Lokalise, Phrase)
• Avoid pure machine translation for primary content — Google penalizes thin translations
• Adapt cultural references: examples, idioms, holidays, business norms
• Translate testimonials and case studies from local clients (more credible than translated US case studies)
• Build per-region content marketing strategies — German B2B differs from US B2B
• Localize SEO keyword research per region — direct translations rarely match search volume
• Adapt visual design: colors, imagery, layouts based on cultural preferences
• Test localized pages with native speakers before launch

Code Example — Locally-relevant testimonials per region:

<section class="testimonials" data-region="en-gb">
  <!-- UK testimonials shown only on /en-gb/ pages -->
  <article class="testimonial">
    <blockquote lang="en-GB">
      "ThatDeveloperGuy transformed our Manchester firm's online presence.
      We're now ranking nationwide for our key terms — bloody brilliant work."
    </blockquote>
    <cite>— Sarah Mitchell, Director, Mitchell & Co (Manchester, UK)</cite>
  </article>
</section>

<section class="testimonials" data-region="es-mx" hidden>
  <!-- Mexico testimonials shown only on /es-mx/ pages -->
  <article class="testimonial">
    <blockquote lang="es-MX">
      "Joseph y su equipo entendieron perfectamente nuestro mercado en CDMX.
      Resultados increíbles en solo 90 días."
    </blockquote>
    <cite>— Carlos Hernández, Director, Hernández Consultores (CDMX, MX)</cite>
  </article>
</section>

<script>
// Show testimonials matching current page's region
const pageRegion = document.documentElement.lang;
document.querySelectorAll('[data-region]').forEach(section => {
  section.hidden = section.dataset.region !== pageRegion;
});
</script>

• Validation: Native-speaker translations on all primary content, region-specific testimonials displayed, native-speaker QA reviews completed

Summary

• Total items: 8
• Sub-clusters: 3 (International Foundation, Geographic & Domain Strategy, Localization & Cultural)
• Format: Each item includes 7–8 implementation steps, a code example, and a validation criterion
• Net change from original: 0 dropped, 3 added (GTR, CUL, TCM), 5 renamed for consistent 3-letter codes
• Position in stack: Global expansion tier — depends on Tiers 1–11, enables international scale while preserving local authority

About this series

This is one of 14 articles in ThatDevPro’s Engine Optimization stack — a productized SEO + AEO + AIO + GEO service. Each tier is a self-contained framework with concrete checklists, validation steps, and code patterns.

Canonical source for this article: https://www.thatdevpro.com/insights/seo-tier-12-international/

The 14-tier series:

1. Tier 1 — Foundation
2. Tier 2 — Search Visibility
3. Tier 3 — AI Domination
4. Tier 4 — Entity and Authority
5. Tier 5 — Local Domination
6. Tier 6 — Content and Multimedia
7. Tier 7 — Social and Community
8. Tier 8 — Data, Analytics, Conversion
9. Tier 9 — Monitoring and Intelligence
10. Tier 10 — Workflow and Operations
11. Tier 11 — Marketplace and Retail
12. Tier 12 — International
13. Tier 14 — Advanced and Immersive

Tier 13 is retired.

Need this implemented on your site? ThatDevPro ships the full 14-tier stack as a productized service. SDVOSB-certified veteran-owned. Cassville, Missouri. See the Engine Optimization service.

Open-source tooling powering this series:

• aio-surfaces — Python toolkit (MIT) for generating llms.txt + aeo.json + entity.json + brand.json
• llms.txt generator — live Hugging Face Space

AI Coding Tools 2026: Cursor vs GitHub Copilot vs Claude Code (Real Comparison)

If you write code for a living, you’ve probably noticed that AI coding assistants went from “nice to have” to “non-negotiable” sometime in 2025. And by mid-2026, the market has clearly stratified into three tiers:

1. Best all-around: Cursor ($20/month)
2. Best for enterprise: GitHub Copilot ($10-20/month, often bundled with Copilot Pro)
3. Best for AI researchers & power users: Claude Code (free CLI, paid through Anthropic)

This article breaks down which tool actually wins for different workflows, based on real usage data from developers shipping products in 2026.

The Core Difference: Context Is Everything

Every AI coding tool does the same fundamental thing: it predicts the next characters you’ll type. But the quality of that prediction depends entirely on how much context the model can “see.”

GitHub Copilot looks at your current file + import statements.
Cursor looks at your entire project — every file, folder structure, and dependencies.
Claude Code looks at whatever you paste into it, but has 200K token context window (basically your entire codebase).

For fixing bugs in a 50-file codebase? Cursor and Claude win. For writing a quick script? Copilot is fine.

GitHub Copilot: The Safe Enterprise Choice

Price: $10-20/month depending on plan
Best for: Teams that already use GitHub, corporate environments
Training data: Trained on public GitHub (with opt-out available)

GitHub Copilot is the market leader by sheer distribution — it ships integrated into VS Code, and most Fortune 500 companies use it because IT departments trust GitHub (owned by Microsoft).

What it does well:

• Fast completions, minimal lag
• Works in every major IDE
• Copilot Chat is genuinely useful for explaining code
• Good for standard patterns (loops, API calls, data transformations)

Where it falls short:

• Can’t “see” your full codebase — only the current file
• Suggestions are sometimes generic (copy-pasted from Stack Overflow)
• Limited context means it often suggests patterns that conflict with your project structure
• Hallucination rate on complex refactoring is ~20-30%

Real-world example: You’re refactoring a database query that appears in 12 files. Copilot only sees the current file, so it might suggest a pattern that breaks consistency in the other 11. Cursor would see all 12 and maintain consistency.

Cost-benefit: $10-20/month is negligible for most developers. The real cost is context blindness.

Cursor: The Productivity Multiplier

Price: $20/month (or free with limited features)
Best for: Solo developers, startups, anyone shipping fast
Best feature: @codebase — indexes your entire project and uses it for context

Cursor is purpose-built for developers. It’s a full code editor (forked from VS Code) with Cursor-specific features. If you write code every day, this is the tool that will cut your shipping time.

What it does well:

• @codebase command: Ask it “where is the user authentication logic?” and it finds it across 50 files
• Multi-file refactoring with perfect consistency
• Knows your project’s conventions and style
• Excellent at generating test suites that actually pass first time
• Built-in terminal lets you run code and iterate without context-switching

Where it falls short:

• You have to switch editors (VS Code → Cursor)
• Sometimes over-generates code when you only need a small fix
• Context is limited to what fits in 200K tokens (still massive, but your codebase might exceed it)

Real-world example: You want to add a new feature to your API. You tell Cursor: “Add a /users/:id/settings endpoint that follows the same pattern as the /products/:id endpoint.” Cursor reads both endpoints, maintains the exact same error handling and middleware, and generates the new endpoint in 5 seconds. GitHub Copilot would need you to manually show it the /products endpoint first.

The workflow: Most developers using Cursor report 2-3x faster feature shipping. That compounds.

Claude Code: The Thinking Tool

Price: Free (Claude API costs extra)
Best for: Complex refactoring, architectural decisions, learning
Best feature: 200K token context window means it can ingest your entire codebase at once

Claude Code isn’t an IDE — it’s a CLI that lets you run Claude’s API on your local codebase. It’s the tool for the kind of coding that requires reasoning, not just pattern-matching.

What it does well:

• Best reasoning about architecture and design patterns
• Excellent at explaining why code is broken
• Can analyze your entire codebase at once and suggest systemic improvements
• Good for one-shot, high-stakes refactoring (e.g., “migrate this Django app to FastAPI”)

Where it falls short:

• Not real-time — you have to explicitly invoke it
• Requires API keys and pay-per-token pricing
• No IDE integration (you edit in your normal editor, then run Claude Code separately)
• Slower than Cursor for day-to-day coding

Real-world example: You want to refactor a 5-year-old codebase with inconsistent patterns. You run claude-code /path/to/repo --analyze and get a 10-page report on architectural debt, then ask it to generate a migration plan. GitHub Copilot can’t do this — Cursor could, but Claude Code is cheaper for one-off analysis.

The Verdict: Which Should You Use?

If you’re a solo developer or in a startup: Use Cursor. The $20/month pays for itself in shipped features within a week.

If you’re in an enterprise: Use GitHub Copilot. Your IT department already approved it, and it’s integrated into your workflow.

If you’re optimizing a large codebase: Use Claude Code for analysis, then Cursor for implementation.

What’s Actually Changed in 2026

A year ago (2025), the choice was binary: Copilot or nothing. In 2026, we have three distinct tools competing for fundamentally different use cases. Cursor’s project-wide context is the biggest innovation — it’s what made the jump from “helpful” to “productivity multiplier.”

The consolidation will probably happen in 2027 when Microsoft integrates project context into Copilot (they’re definitely building it). Until then, Cursor has the edge for developers who ship fast.

Want to ship faster? Try Cursor free for 2 weeks. Most developers either commit or go back to Copilot within the trial period.

Full disclosure: This article contains affiliate links. If you purchase Cursor through our links, we may earn a commission at no cost to you.

AI tools are now part of the everyday software workflow for many developers. They can help with scaffolding, debugging, explanation, refactoring, test ideas, documentation, and fast exploration. Used well, they compress the time between question and insight.

But speed is not the same thing as quality.

For frontend developers, this distinction matters because our work sits directly between product logic and human experience. A component is rarely just a component. It may carry accessibility decisions, loading states, validation rules, performance trade-offs, analytics events, error handling, security assumptions, and user trust.

That is why I think AI-assisted engineering needs a disciplined checklist.

1. Understand the problem before asking for code

If the prompt starts before the thinking starts, the output will usually be shallow. Before asking an AI tool to generate a solution, define the user problem, the technical constraint, and the quality bar.

A better prompt often starts with context rather than command: what the component is for, who uses it, what can go wrong, and what stack constraints exist.

2. Ask for trade-offs, not only answers

A code answer can look correct while hiding weak assumptions. Asking for trade-offs forces the tool to surface alternatives: client vs server rendering, controlled vs uncontrolled state, optimistic updates vs explicit confirmation, library vs custom implementation.

The value is not only the final snippet. The value is the comparison.

3. Review generated code like it came from a junior teammate

Generated code deserves a real review. Naming, types, state boundaries, dependencies, accessibility attributes, loading states, testability, and failure paths all need human inspection.

This is not cynicism. It is engineering ownership.

4. Check product-facing details yourself

AI is often good at the happy path and weaker at the lived product path. Frontend quality depends on details such as empty states, long text, keyboard navigation, responsive behaviour, slow networks, API errors, and partially completed forms.

Those details are where users feel the quality of the product.

5. Refactor until the solution fits the system

A generated solution may solve the isolated prompt but still not fit the codebase. The real work is shaping it into the existing architecture, design system, naming conventions, test patterns, and performance expectations.

Good developers do not just paste. They integrate.

6. Keep learning the underlying technology

The strongest AI-assisted developers are not the ones who know the least. They are usually the ones who can judge the output because they understand the fundamentals.

React, Next.js, TypeScript, accessibility, browser behaviour, APIs, and product thinking still matter. AI increases leverage, but leverage without judgement increases risk.

Conclusion

AI can make software engineers faster, but speed only becomes valuable when it is paired with responsibility. My own rule is simple: use AI to accelerate the work, but keep responsibility for the outcome.

You do not need a perfect beginning to build serious technical skill. You need curiosity, discipline, ethics, and the courage to keep learning when no one is clapping yet.

— Rizwan Saleem

UK-based Lead Frontend Developer, AI/LLM practitioner, fintech/open banking engineer, software engineer, and startup founder

More: https://rizwansaleem.co

• [Choosing rule candidates that actually reduce risk]
• [Designing detections that stay quiet and precise]
• [Testing rules: unit tests plus a real-code corpus]
• [Documenting examples, safe autofix, and developer ergonomics]
• [A compact rollout checklist, deprecation policy, and metrics you can run this week]

Low-noise custom linter rules are the single biggest multiplier for consistent engineering behavior across a codebase. I’ve written and shipped eslint rules, semgrep rules, and AST codemods at scale; the ones teams keep enabled follow a predictable pattern I’ll show you.

Noisy rules show up as a long tail of false positives in PRs, a steady stream of eslint-disable comments, and latency in code review. The operational symptoms are familiar: developers ignore an entire ruleset because triage turns into daily work, CI bounces become a productivity tax, and the rules you intended to prevent regressions become a source of churn instead.

Choosing rule candidates that actually reduce risk

Picking what to write matters more than perfecting the rule implementation. Prioritize candidates that are (a) easy to reason about, (b) actionable in a few lines of change, and (c) frequent or high-impact in production.

• Data-first signals to surface candidates:
  • Security findings and recurring alerts from your SAST (CodeQL, Semgrep) — these point to patterns that already produced risk. Use those as seed patterns.
  • Issue/bug tracker tags (security, performance) and on-call incident logs — correlate stack traces or file paths to identify hotspots.
  • Repo churn metrics: files with high commit frequency or long open PRs are good containment scopes for rules.
• Low-hanging, high-value examples:
  • For web apps: forbid use of eval, innerHTML, or other dangerous APIs in production paths. (Use a language-aware matcher, not plain grep.)
  • For platform libraries: ban internal-only APIs in public modules; flag deprecated company APIs to accelerate migration.
• Why start with small scopes:
  • Narrow scopes let you reason about false positives before widening coverage. Prefer a focused rule (e.g., no-internal-auth-call in packages/auth/*) over monolithic no-insecure-code rules across the whole monorepo.

Important: Use semantic scanners (CodeQL or Semgrep) when you need taint or dataflow analysis to reduce false positives; these engines are designed for semantic queries rather than blanket text-pattern matching.

Designing detections that stay quiet and precise

Precision beats coverage when your goal is adoption. Design rules so they trigger only when you have high confidence that the flagged code truly violates the intended contract.

• Keep the detection narrow
  • Anchor patterns to imports, callsites, or specific AST node shapes instead of broad regexes.
  • Use file globs / overrides to exclude test fixtures, mocks, or tooling code that legitimately uses “unsafe” constructs.
• Add contextual checks
  • Prefer AST-level checks (ESLint visitors, Semgrep patterns, TypeScript-aware checks) to string matching; AST node types and parent context reduce noise. Use @babel/types or the tools’ AST helpers to inspect nodes.
  • Where available, consume type information via @typescript-eslint to disambiguate overloaded symbols or type-only uses (typed linting). Type-aware rules reduce class-of-false-positives.
• Handle ambiguity with suggestions instead of hard fixes
  • When a transform could change semantics (renames of exported symbols, refactors across modules), provide a suggest in ESLint or an autofix candidate in Semgrep rather than a forced rewrite. ESLint supports suggest entries and fix functions; meta.fixable is required for fixable rules.
• Example: an opinionated-but-precise ESLint rule skeleton

// lib/rules/no-internal-foo.js
module.exports = {
  meta: {
    type: "problem",
    docs: { description: "Disallow _internal.foo usage", recommended: false },
    fixable: "code", // required for automatic --fix behavior
    messages: { avoidInternal: "Use the public `foo()` API instead of `_internal.foo`." }
  },
  create(context) {
    return {
      MemberExpression(node) {
        // pseudo helpers: isIdentifier(node.property, "_foo") and isFromInternalModule(node)
        if (node.property.name === "_foo" && isFromInternalModule(node)) {
          context.report({
            node,
            messageId: "avoidInternal",
            fix: fixer => fixer.replaceText(node.property, "foo")
          });
        }
      }
    };
  }
};

• Tooling notes: ESLint provides a fixer API with methods such as replaceText, insertTextAfter, and a best-practices section on safe fixes. Use those primitives for minimal, reversible edits.

Testing rules: unit tests plus a real-code corpus

Reliable rules are testable rules. Testing falls into two buckets: unit tests (fast, deterministic) and corpus-level testing (real-world signal).

• Unit tests (fast feedback)
  • For ESLint write RuleTester suites that enumerate valid and invalid code samples, desired messages, and expected output when your fix applies. This makes the rule behavior crystal-clear and prevents regressions.

const { RuleTester } = require("eslint");
const rule = require("../../../lib/rules/no-internal-foo");

const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 2020, sourceType: "module" } });
ruleTester.run("no-internal-foo", rule, {
  valid: [
    "import { foo } from 'public-lib'; foo();"
  ],
  invalid: [
    {
      code: "import { _foo } from 'internal'; _foo();",
      errors: [{ messageId: "avoidInternal" }],
      output: "import { foo } from 'public-lib'; foo();"
    }
  ]
});

• For Semgrep, use its built-in test annotations (ruleid:, ok:, and the --test runner) to declare positive and negative examples inline with the target code.

# /targets/detect-eval.py
# ok: detect-eval
safe_eval(user_input)

# ruleid: detect-eval
eval(user_input)

• Corpus testing (real-world signal)
  • Run the rule across the full repo (and a set of representative repos) and sample findings for manual labeling. Use rg / git grep to collect candidates, then run the linter across those files and collect results.
  • Measure precision empirically: label N findings (e.g., 200–500) and compute true positives fraction. Prioritize rules with high precision for automatic enforcement.
  • Track runtime: record rule execution time and memory on large modules to ensure editor/CI ergonomics; huge rules should run in CI only or be optimized with cached ASTs.
• Regression testing and snapshotting
  • For complex autofixes, include snapshot-based tests that assert the output after fix application; some teams use a snapshot harness to record result.output so future changes are visible as diffs.
• Tooling references:
  • ESLint RuleTester and the developer guide explain how to structure unit tests.
  • Semgrep provides an explicit test harness and annotations for expected results.

Documenting examples, safe autofix, and developer ergonomics

Developer trust grows from clarity. Documentation, examples, and ergonomics make or break adoption.

• Documentation checklist
  • Why the rule exists: cite the bug or incident that motivated it or the policy it enforces.
  • Minimal repro: short “bad” and “good” code blocks (copy/paste runnable examples).
  • Fix recipe: step-by-step manual fix, and what the autofix will do if available.
  • Configuration knobs: explain options, globs, and how to relax severity in local overrides.
  • Opt-out policy: explain when // eslint-disable is acceptable and the approval process to keep it rare.
• Autofix rules: safe-first approach
  • Only auto-fix semantics-preserving, localized changes (renaming a private identifier within the same file, formatting, removing unused imports).
  • For multi-file refactors, provide an ast codemod and an automated PR rather than an auto-fix that runs as part of developers’ normal --fix pass.
  • Semgrep supports autofix infrastructure in its platform; enabling autofix for the organization is an explicit toggle. Test autofix behaviors with Semgrep’s --test harness to compare fixed output to expected output.
• AST codemods for heavy lifting
  • For cross-file or structural refactors, write jscodeshift or babel transforms and land them as separate, reviewable PRs. These tools let you perform deterministic AST rewrites and are the right choice for registry-wide migrations.

// example jscodeshift transform (transform.js)
export default function transformer(file, api) {
  const j = api.jscodeshift;
  const root = j(file.source);
  root.find(j.Identifier, { name: "_foo" }).forEach(p => { p.node.name = "foo"; });
  return root.toSource();
}

• Developer ergonomics
  • Expose rule behavior in editor tooling (VSCode ESLint plugin), and surface suggest entries so a developer can accept a fix from the editor instead of wrestling with diffs.
  • Keep feedback local and fast: aim for developer feedback in the editor, then CI as the final gate.

A compact rollout checklist, deprecation policy, and metrics you can run this week

This is the operational playbook you can run immediately to get a rule from prototype to trusted.

1. Prototype and unit-test (1–3 days)
   • Implement the minimal AST-aware detection.
   • Add RuleTester / Semgrep tests with valid/invalid cases and fix output for autofixable examples.
2. Corpus run and precision check (2–4 days)
   • Run across your repo and sample N = 200–500 findings; label true/false positives and compute precision.
   • If precision < target threshold (team-defined; many teams aim for high-90s for auto-enforcement), narrow the rule.
3. Canary rollout (1–2 weeks)
   • Publish the rule as recommended: false and enable it in CI on PRs as warning or as a bot that comments with the finding (no hard failure). Use a GitHub Action to run the linter on PRs and report annotations.

name: Lint (PR)
on: [pull_request]
jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install dependencies
        run: npm ci
      - name: Run ESLint
        run: npm run lint -- --max-warnings=0

1. Gradual enforcement (4+ weeks)
   • After observing low false-positive counts and developer acceptance, flip severity to error in CI for targeted paths and then expand scope.
2. Full enforcement and autofix sweep
   • For purely stylistic or safe fixes, run an automated codemod PR that applies fixes across the codebase and submit it as a bulk migration.
3. Deprecation policy (rule lifecycle)
   • Each rule must include meta.docs.deprecated and meta.docs.replacedBy where relevant; document the planned sunset date and migration path in the rule README. Tooling like eslint-docgen can surface deprecated metadata automatically.
4. Governance
   • A lightweight review board (2–3 engineers) approves new rules and deprecations. Rules require unit tests, corpus run results, and a rollout plan before approval.

Metric table (use these to decide whether to widen scope or deprecate a rule):

• Collect data with a small telemetry pipeline: run the rule on incoming PRs, emit structured annotations (JSON) to a storage bucket, and run nightly aggregation to compute precision and adoption trends.
• Use CodeQL / Semgrep for higher-confidence semantic detections and to cross-check new rules against known CWEs from OWASP when the rule is security-related.

Governance minimums: every rule must ship with tests, a README with example fixes, and a canary rollout plan that includes a precision measurement after 1,000 findings or 2 weeks, whichever comes first.

Ship small, measure precisely, and automate the low-risk fixes. The rules that survive are the ones that respect developer time, provide clear remediation, and can be rolled back or deprecated with an audit trail and migration artifacts.

Sources:
Working with Rules — ESLint (developer guide) – Documentation on context.report, fix/fixer, meta.fixable, suggestions and best practices for writing ESLint rules and fixes.

Test rules | Semgrep – Semgrep’s testing annotations and --test workflow including ruleid, ok, and autofix testing behavior.

Overview | Semgrep (Rule writing) – How Semgrep rules are written, their pattern + dataflow capabilities, and examples.

jscodeshift docs – Guidance for writing and running AST codemods using jscodeshift.

@babel/types — Babel – API reference for AST node builders and node type checks useful when authoring AST transforms.

eslint/github-action (GitHub) – Official GitHub Action for running ESLint on pull requests and CI.

CodeQL documentation – CodeQL overview and using semantic queries for vulnerability discovery across codebases.

OWASP Top 10:2021 – Standard awareness document for the most critical web application security risks used to prioritize rule targets.

Run the Tests — ESLint contributor guide (RuleTester) – Usage of RuleTester and unit-test recommendations for rules.

eslint-docgen (npm) – Tooling that can generate rule docs from meta fields like deprecated and replacedBy.