and meta description (dup titles trigger duplicate clustering) - How: Audit your URLs. Look for patterns like ?sid= , ?phpsessid= , ;jsessionid= . If they exist, fix at the source. · Configure your server or framework to not include session IDs in URLs. In PHP: // php.ini session.use_only_cookies = 1 session.use_trans_sid = 0 · In Java/Servlet containers (Tomcat etc.), disable URL rewriting for sessions: // Disable in web.xml <session-config> <cookie-config> <http-only>true</http-only> </cookie-config> </session-config> · Add canonical tags to all URLs (should not include session IDs in the canonical href). · Block session ID patterns in robots.txt as a fallback: Disallow: /*?sid= - Avoid: Adding the canonical but keeping the session ID in the canonical href (defeats the purpose) · Blocking the pattern in robots.txt but not fixing the source (other crawlers may ignore robots.txt) · Not realizing the Java web framework defaults to URL session rewriting (this is a real production gotcha) - Verify: Browse your site as an unauthenticated visitor. Inspect URL bar. No session IDs. · Run a Screaming Frog crawl. No URLs should contain session parameters. - [ ] **30.** Set a preferred domain and enforce HTTPS canonical; redirect HTTP→HTTPS site-wide - How: Get a valid SSL certificate. Let's Encrypt is free and automated. · Configure your server to redirect all HTTP to HTTPS. In nginx: server { listen 80; server_name yoursite.com www.yoursite.com; return 301 https://yoursite.com$request_uri; } · Update all internal links to use HTTPS. Find and replace across your codebase. · Add HSTS to lock HTTPS: add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always; · Add the HTTPS property to GSC. Set the HTTPS version as preferred. - Avoid: Allowing mixed content (HTTPS page loading HTTP images, scripts, or iframes — browsers block these) · Forgetting to update external integrations (CDN, third-party scripts, webhooks) to use HTTPS · Not setting HSTS (allows SSL stripping attacks) · Forgetting to renew the SSL cert (Let's Encrypt is 90 days; expired certs are demoted) - Verify: curl -I http://yoursite.com/ should 301 to https://yoursite.com/ . · View source on every page type. No mixed-content warnings in Chrome DevTools. · Test with SSL Labs — aim for A+. - [ ] **31.** Handle UTM/tracking params with canonical to the clean URL - How: For your product/category pages, identify which facets are useful for users vs which just create duplicates: Useful (indexable): primary category, brand, primary use case · Less useful (noindex or block): color, size, price range, secondary filters · · For non-indexable facets: Add rel="nofollow" to the internal links pointing to them · Add noindex meta on the resulting URL (or canonical to the base URL) · Block via robots.txt as a backup · · For indexable facets, generate a real canonical URL with descriptive content. E.g., /shoes/running has its own title, description, and intro — not just a filtered list. · Use a single canonical for filtered URLs that points back to the base. Example: /shoes?color=red canonicals to /shoes . - Avoid: Indexing every facet combination ("red Nike running shoes size 10" gets 5 different indexable URLs) · Using JavaScript-only filter changes (creates URLs Google can't see but users see as different) · Not having unique content on indexable facet pages (Google's "thin content" filter will hit them) - Verify: Apply several facet combinations. Verify each combination either has a canonical to the base OR is blocked by robots.txt. · Check GSC → Pages over 4 weeks. The count of "faceted" URLs in the index should be 0 or near 0. - [ ] **32.** Localize duplicates correctly: same-language regional variants need hreflang, not canonical, between them - How: Decide the original. Your site is the canonical source. The syndication partner republishes but signals you as canonical. · On the syndicated version, add: <link rel="canonical" href="https://yoursite.com/original-article"> · On your original, no change needed. The syndicated version canonicals back to you. · For Medium: when you import, Medium automatically adds a canonical to your original. Verify this happened. · For LinkedIn: LinkedIn doesn't support rel=canonical in articles. Use a "Originally published at [link]" link at the top, and don't syndicate the same content to multiple partners (each adds noise). - Avoid: Letting the syndication partner rank for your article (because they didn't add the canonical, or added it incorrectly) · Syndicating to multiple partners without checking each canonicalizes properly (Google may pick the wrong one) · Not linking back to your original from the syndicated version (helps users and signals authority) - Verify: Find a syndicated article. View source. Confirm the canonical points to your original. · Search the article's title in Google. Your site should rank, the syndicated version should not (or rank below you). ## C · Architecture and internal linking _16 actions, #33–48_ Internal links are the only ranking factor you control completely. They tell Google which pages matter, and they carry authority from the pages that have it to the pages that need it. - [ ] **33.** Keep every important page ≤3 clicks from the homepage - How: Map your content. Group every page into 3-7 main topics (e.g., for a marketing site: SEO, GEO/AI, Local, Schema, Content). · For each topic, have: A pillar page (broad overview, links to all subtopics) · Cluster pages (specific deep-dives, link back to the pillar) · Detail pages (specific items, link up to the cluster) · · Establish a URL hierarchy: /topic/ (pillar) /topic/subtopic/ (cluster) /topic/subtopic/item/ (detail) · Internal links should reinforce the structure: cluster pages link to the pillar, detail pages link to both. · Aim for "3 clicks from anywhere." If a page is deeper than 3 clicks, it may be an orphan or buried too deep. - Avoid: Going 5+ levels deep (URLs get long, signal weakens at each level) · Cross-linking everything to everything (drowns the actual structure in noise) · Reorganizing without 301 redirects (loses the equity built up in old URLs) · Having a flat structure (no topics) — Google sees the site as a soup of pages with no topical authority - Verify: Draw your site structure on paper. Each page should have a clear parent topic. · Run Screaming Frog → "Site Structure" visualization. Look for orphan pages and overly deep pages. · Check: from your homepage, can you reach any page in 3 clicks? - [ ] **34.** Build one pillar page per core topic; link every cluster article up to its pillar and back down - How: Identify a topic with 5+ related subtopic pages. That's your hub candidate. · Create (or repurpose an existing page as) the hub. The hub should: Cover the topic at a high level (~1500-2500 words) · Link to every subtopic page in the cluster · Have a clear table of contents or section structure · Be the most authoritative single page on the topic · · From each subtopic page, add a link back to the hub ("Back to: [Hub title]"). · Update the site's main navigation to include hubs in their respective sections. · Promote the hub from your homepage or main topic page. - Avoid: Hub page is too short (under 800 words) — doesn't have enough authority to concentrate signals · Hub page is a list of links only (no real content above the links) · Hub page doesn't link to all the cluster pages (some signals get stranded) · Multiple hub pages for the same topic (splits the authority) - Verify: From the hub, count the links to subtopic cluster pages. Should be at least 5, ideally all of them. · From each subtopic, count the back-links to the hub. Should be 1+ each. · Run an internal-link audit with Screaming Frog. The hub should be one of the most linked-to pages on the site. - [ ] **35.** Add 3–10 contextual in-body internal links per page (not just nav/footer) - How: For each new or existing content piece, when you mention a concept that's covered elsewhere on your site, link to that page. Example: in an article about sitemap.xml, link to your article about <lastmod> . · Aim for 3-10 contextual links per page. More than 10 starts to look spammy. Less than 3 means you're missing linking opportunities. · Use descriptive anchor text. "Learn more about XML sitemaps" not "click here". · Link to pages that are relevant to the surrounding content, not pages you're trying to rank for the sake of it. Relevance > volume. · For old content, audit and add new internal links as you create new content. New pages should link back to old ones in the same topic area. - Avoid: Using "click here" or "read more" as anchor text (wastes the relevance signal) · Linking to the same page multiple times from the same page (consolidate into one link) · Adding 30+ links per page (dilutes the signal, looks spammy) · Linking to the same destination from every page (Google ignores the duplicate) - Verify: On a 1500-word page, count contextual links. Should be 3-10. · Sample 10 pages. Check the anchor text of internal links. Is it descriptive, not generic? · Use Screaming Frog to map internal links. Are there pages with very few internal links pointing to them (orphans or under-linked)? - [ ] **36.** Use descriptive 2–5 word anchor text on internal links; never "click here"/"read more" for key targets - How: For any important destination URL, use a mix of anchor texts: Exact match: "XML sitemaps" (link to /xml-sitemaps) · Partial match: "how to set up sitemaps" (still relevant) · Branded: "Acme's sitemap guide" (safe) · Generic: "read this guide" (least SEO value but natural) · URL: "acme.com/xml-sitemaps" (works but ugly) · · Don't engineer the exact-match ratio. Aim for natural variation — usually 30-40% exact, 30% partial, 20% branded, 10% other. · Avoid: 100% exact-match anchor text (a clear manipulation pattern). - Avoid: Same anchor text on every link to the same page (Google ignores most of them) · Using off-topic anchor text (links "cheap shoes" to a page about XML sitemaps) · Over-optimizing exact-match anchors (looks like manipulation) - Verify: For an important URL, sample all internal links pointing to it. Note the anchor texts. · Are they varied? Are they all on-topic? · Check external links too (with a tool like Ahrefs or Majestic). External anchor diversity matters more than internal. - [ ] **37.** Link every new post from ≥3 topically related existing pages within 24h of publishing - How: Run Screaming Frog. Filter by "Orphan Pages." This shows every page that has zero internal links pointing to it. · For each orphan page, decide: Important content: add internal links from relevant pages · Outdated content: redirect to a current page or noindex it · Low-value content: noindex it or delete it · · Common causes of orphans: Page exists in CMS but no one links to it (forgotten content) · URL changed but internal links not updated · New category added but no nav link to its children · · For new content, add it to relevant hub pages, related articles, and the site's nav or footer as appropriate. - Avoid: Adding new content and forgetting to link to it from existing pages · Having a "recent posts" widget as the only place a page is linked (Google can find it but it's still a weak signal) · Not auditing for orphans regularly (the count grows as content ages) - Verify: Run Screaming Frog → Orphan Pages filter. Aim for 0 (or only pages you intentionally want to be hard to find). · Add the orphan check to your monthly audit. - [ ] **38.** Find and fix orphan pages (Screaming Frog → Orphan URLs vs sitemap) by adding internal links - How: Implement structured breadcrumbs with schema.org markup. JSON-LD: { "@context": "https://schema.org", "@type": "BreadcrumbList", "itemListElement": [ {"@type": "ListItem", "position": 1, "name": "Home", "item": "https://yoursite.com/"}, {"@type": "ListItem", "position": 2, "name": "SEO", "item": "https://yoursite.com/seo/"}, {"@type": "ListItem", "position": 3, "name": "Schema markup", "item": "https://yoursite.com/seo/schema/"} ] } · Render visible breadcrumbs in your template. The path should match the URL structure. · Each breadcrumb should be a clickable link (except the current page, which is plain text). · Place breadcrumbs near the top of the page, before the main content. - Avoid: Breadcrumbs that don't match the URL structure (inconsistency confuses users and Google) · Missing schema markup (Google may not display breadcrumbs in SERPs) · Breadcrumb links that all go to the homepage (no actual hierarchy) · Breadcrumbs in a tiny font at the very bottom of the page (low visibility) - Verify: Open a deep page on your site. Confirm breadcrumbs are visible and reflect the URL structure. · Validate the BreadcrumbList schema with Schema.org validator . · After Google recrawls, check GSC → Enhancements → Breadcrumbs for any errors. - [ ] **39.** Push link equity to money pages: link them from the homepage and high-authority posts - How: Identify the most important destinations for users and search. These belong in the footer: Main topic/category pages (3-7) · About, Contact, Blog · Privacy, Terms · Resources (llms.txt, sitemap, RSS) · · Keep the footer to 4-5 columns of links, 5-8 links per column. Total: 20-40 footer links. · Order columns by importance: most important navigation first. · Use real anchor text, not icons. (Google can't read most icons without alt text.) - Avoid: Stuffing the footer with 200+ links (looks manipulative, dilutes the value of each) · Using the same footer across the whole site without thought (it's a global nav, treat it that way) · Having footer links to pages that don't exist or 404 (use GSC to verify) - Verify: Count your footer links. Should be 20-40. · Check: does every footer link resolve to a 200 page? · Run Screaming Frog → "All" → filter by "Inlinks > 0." Every page in your footer should be linked to by every other page. - [ ] **40.** Add breadcrumb navigation site-wide + BreadcrumbList schema - How: Use algorithmic related-posts (not just "most recent"). Look at: Same category/tag · Same keywords in title or first paragraph · High overlap in content (TF-IDF or simple keyword matching) · · For WordPress, plugins like JARVIZ or Related Posts for WP do this. · For custom sites, compute relatedness on the server. Use Jaccard similarity on tokenized content, or cosine similarity on TF-IDF vectors. · Display 4-6 related posts. Below the article, not in a sidebar (above the fold on mobile is wasted on related content). - Avoid: Showing the same related posts on every page (algorithmic bug, suggests no actual relevance calculation) · Showing 20+ related posts (overwhelming, dilutes CTR on each) · Showing off-topic content (recommendation algorithm is broken) · Auto-linking to your most-trafficked pages regardless of relevance (Google may see it as PageRank sculpting) - Verify: On 5 different content pages, check the related posts. Are they actually related? · Click through to a related post. Does the relevance hold across the click? - [ ] **41.** Keep a flat-ish depth: avoid pages buried >4 folders deep with no internal links - How: For every internal link on a page, check the anchor text: Is it descriptive? (Names the destination topic) · Is it relevant? (Matches the surrounding sentence) · Is it not generic? (Avoids "click here", "this article", "read more") · · When you can't find a good natural fit, rephrase the surrounding sentence. Don't force "click here" to link to your XML sitemap guide. · For images used as links, the alt text serves as the anchor text. Make it descriptive too. - Avoid: Using "Read more" as the entire anchor (no information, no value) · Using the URL as the anchor (ugly, no context) · Using "this article" or "this post" as the anchor (vague) · Using image alt text as the only descriptive link element (works but text is better) - Verify: Sample 20 internal links across your site. Note the anchor text. Is it descriptive? · Run Screaming Frog → "All" → "Anchor Text" filter. Look for common low-value anchors ("click here", "read more"). - [ ] **42.** Add HTML sitemap / hub pages for large sections to distribute crawl and equity - How: For every facet link in your UI (color filter, size filter, sort options), decide: Is the resulting URL a useful, indexable page? (Like /running-shoes vs /shoes?type=running) — then nofollow isn't needed · Is it a near-duplicate of the base? (Like /shoes?color=red) — then nofollow · · For non-indexable facet links, add rel="nofollow" : <a href="/shoes?color=red" rel="nofollow">Red</a> · For JavaScript-rendered facets, use the API-level nofollow equivalent (don't render the link, or render it as a button that triggers a state change). · Block the patterns in robots.txt as a backup. - Avoid: Nofollowing links that lead to real indexable content (wastes PageRank flow) · Forgetting nofollow on JavaScript-rendered facet changes (they still create URLs) · Nofollowing without canonical or robots.txt protection (Google may still discover the URLs from external links) - Verify: Apply 5 facet combinations in your UI. Check the resulting URLs and their canonical tags. · Each facet URL should be either noindex, canonical-to-base, or blocked by robots.txt. - [ ] **43.** Limit on-page links to a reasonable count; avoid diluting equity with hundreds of footer links - How: You can't directly ask Google for sitelinks, but you can increase your chances: Have a clear site structure with prominent nav links to important pages · Use descriptive, distinct anchor text for those nav links ("About us" not just "About") · Use a clear, text-based navigation (not just images or JavaScript) · Have unique titles and meta descriptions for each subpage · · Avoid using nositelinkssearchbox meta tag (which would actively prevent Google from showing them). · Wait. Google generates sitelinks algorithmically. They're not guaranteed, and Google may add or remove them over time. - Avoid: Looking for ways to force sitelinks (you can't, and trying to game them often backfires) · Using nofollow on your main nav (wastes the signal that helps Google identify these as important pages) · Having nav links to low-quality pages (Google may show those instead of the ones you want) - Verify: Search site:yoursite.com in Google. Check if sitelinks appear under your homepage. · If not: check that your main nav is text-based, well-structured, and the most important pages are prominent. · If they appear: don't make sudden structural changes (Google may update sitelinks accordingly). - [ ] **44.** Use rel="nofollow"/sponsored/ugc correctly on paid, user-generated, and untrusted links - How: For paginated archive views (category pages, blog index, search results): Page 1: indexable, canonical to itself · Pages 2+: noindex, OR canonical to page 1 · · For paginated content (an article split across pages, like a 5-part guide): Don't paginate. Use a single page with anchor links to sections. · If you must paginate: each page is indexable with self-referencing canonicals. Use rel="next" and rel="prev" (deprecated as a signal but still works as a hint). · · For WordPress: paginated archive views are usually noindex by default in modern themes. Verify. - Avoid: Having page 2, 3, 4... all as separate indexable URLs with no canonical (creates thin duplicate content) · Using rel="next/prev" thinking it's a current signal (Google deprecated this in 2019) · Not handling page 1 specifically (it should be the canonical version of the archive, not a paginated view) - Verify: View source on /blog?page=2 and /blog?page=3 . Confirm noindex meta OR canonical to page 1. · Use Screaming Frog to crawl your site. Check the "Noindex" filter includes your paginated views. - [ ] **45.** Audit internal anchor-text distribution; ensure target pages get keyword-relevant (not generic) anchors - How: Identify claims in your content that benefit from external citations: Statistics: link to the original study · Industry terms: link to the canonical source (Wikipedia for general topics, official docs for technical) · Quotes: link to the original source · · Use 3-5 outbound links per long-form content piece. Not every sentence needs a link, but claims should be backed. · Open external links in a new tab ( target="_blank" ) to keep users on your site. · Add rel="noopener" to target="_blank" links (security best practice). - Avoid: Linking to low-quality external sites (Google may use this as a quality signal about your page) · Linking to direct competitors (they may rank instead of you for the topic) · Forgetting to open external links in a new tab (users navigate away and don't return) · Adding 30+ outbound links per page (overwhelming, dilutes value) - Verify: Sample 5 long-form pages. Count external links. Should be 3-5 per page. · Check: do the external links open in a new tab? Do they have rel="noopener" ? - [ ] **46.** Link related/next-step content at the end of articles to reduce pogo-sticking back to SERP - How: Configure your server or CMS to return 404 for non-existent URLs (not 200 with a "not found" page — that's a soft-404). · Make the 404 page useful: Clear "page not found" message · Search box (let users find what they were looking for) · Top categories or popular pages (so they can navigate) · Link to your sitemap · · Don't noindex your 404 page. It's not in the index anyway, but for safety don't add an explicit noindex. · Track 404s in GSC → Pages. If you see legitimate content hitting 404, set up a 301 to the right destination. - Avoid: Returning 200 with a "page not found" page (soft-404, confuses Google) · Showing only a blank error message (missed opportunity to keep the user) · Noindexing the 404 page explicitly (redundant, but signals confusion) · Not checking GSC for patterns (legit 404s from broken links should be redirected) - Verify: Visit a non-existent URL on your site. Confirm 404 status code and helpful page content. · Check GSC → Pages for 404 patterns. If a deleted page is getting traffic, 301 it to a replacement. - [ ] **47.** Ensure primary nav is crawlable <a href> (not JS onclick / button-only) - How: Decide if you need one. Most modern sites don't — XML sitemaps + good internal linking is enough. HTML sitemaps add value for: Very large sites (10,000+ pages) where internal linking can't reach everything · Directories or link-collection sites · User-facing "site directory" experiences · · If you build one, organize by topic. Use a real URL structure that mirrors your site's architecture. · Don't auto-generate from your database (will create thousands of links). Curate it. · Add a nofollow attribute to keep the link equity from spilling across the entire site (if your footer already lists everything, the HTML sitemap may be redundant). - Avoid: Adding an HTML sitemap with 5,000 links (looks spammy, overwhelms users) · Not organizing the HTML sitemap by topic (one flat list of every URL is useless) · Forgetting to update it as new content is added (becomes stale fast) · Confusing the HTML sitemap with the XML sitemap (different things, both valid) - Verify: If you have one, check that it loads in a reasonable time and is organized by topic. · Count the links. Should be 50-500 (curated, not auto-generated). · Check that the most important pages are linked from the top of the sitemap. - [ ] **48.** Fix redirected/404 internal links so equity isn't lost in hops - How: Use real words, not IDs or session parameters. · Include the primary keyword in the URL when natural. /xml-sitemap-guide not /post-12345. · Keep it short. Under 75 characters is good. Over 100 starts to look spammy. · Use hyphens, not underscores. Google treats hyphens as word separators, underscores as part of words. · Lowercase only. Mixed case creates duplicate URLs. · Don't change URLs once published. Each change requires 301 redirects and loses some signal. If you must change, set up permanent redirects from the old URL. - Avoid: Including the date in the URL (forces a redirect or staleness when the date changes) · Using underscores (Google sees blue_widgets as one word) · Changing URL structure after the site is established (each change loses signal) · Including category hierarchy in URLs that you'll need to change (like /category/subcategory/post-title) - Verify: Sample 20 URLs. Each should be human-readable, under 75 chars, with hyphens separating words. · Check for stability: don't change URLs unless absolutely necessary. ## D · Speed and Core Web Vitals _30 actions, #49–78_ Speed is a measured signal, not an opinion: Google reads real Chrome data from real visitors. These actions target the three metrics that count, and the render path that produces them. - [ ] **49.** Re-encode photos to AVIF (avifenc --min 20 --max 30), UI/graphics/screenshots to WebP (cwebp -q 80) - How: Understand each metric: LCP — when the largest visible element renders. Good: under 2.5s. · INP — how long the page takes to respond to user interaction. Good: under 200ms. · CLS — how much the layout shifts during load. Good: under 0.1. · · Check your current scores in GSC → Experience → Core Web Vitals . This shows real-user data from Chrome users. · Cross-reference with PageSpeed Insights for the same pages. PSI gives you both lab data (controlled test) and field data (real users). · For each "Poor" or "Needs Improvement" page, identify the dominant issue (usually one metric). Focus your fix on that. - Avoid: Optimizing for lab scores (PSI) and ignoring field data (GSC) — Google ranks on field · Optimizing for LCP only and ignoring INP/CLS — all three matter · Optimizing the homepage and assuming the rest of the site is fine (Google reports per-URL) - Verify: Check GSC → Core Web Vitals monthly. Track the percentage of "Good" URLs. · For URLs in "Poor" category, run PageSpeed Insights. The lab test reproduces the field issue. - [ ] **50.** Serve images via <picture> with AVIF/WebP + a JPEG/PNG fallback <source> - How: Generate three versions of each image: AVIF, WebP, JPEG. Use cavif for AVIF, cwebp for WebP, and your standard JPEG export. · In your HTML, use with multiple sources: <picture> <source srcset="image.avif" type="image/avif"> <source srcset="image.webp" type="image/webp"> <img src="image.jpg" alt="..." width="1600" height="900"> </picture> · Modern browsers (Chrome, Firefox, Safari 16+) will use AVIF. Older browsers fall through to WebP or JPEG. · For WordPress, use a plugin like ShortPixel or Imagify. For Next.js, use the next/image component with AVIF in config. · Verify: open the page, check Network tab. The image request should be .avif or .webp. - Avoid: Using AVIF without a fallback (Safari < 16 and old Android won't show the image) · Forgetting to set width/height on the (causes CLS) · Generating AVIF in lower quality than the source JPEG (no point in modern format if it looks bad) - Verify: Open the page in Chrome DevTools → Network. Find image requests. The format column should show avif or webp for modern browsers. · Compare file sizes: an AVIF should be ~30% smaller than a comparable-quality WebP, which is ~30% smaller than JPEG. - [ ] **51.** Cap in-content images at ≤1600px wide / ≤100KB; hero ≤200KB - How: For body images, export at 1600px max width. For most desktop displays, this is full-width on a 1920px screen. · For hero images, export at 2000px max width. · Run your images through a compressor. Squoosh or cavif -Q 60 (AVIF) usually gets to target size. · For a static site, automate this in your build pipeline. Image optimization should run on every build. · For WordPress, use ShortPixel or Imagify with the right quality settings. - Avoid: Exporting 4000px+ images "for retina" (modern displays don't need more than 2x of the rendered size) · Using uncompressed PNG for photos (use JPEG/WebP/AVIF instead) · Keeping the original full-res image in your CMS even after generating optimized versions (waste of disk) - Verify: Sample 10 images on a page. Each should be under 100KB (body) or 250KB (hero). · Right-click any image → "Open in new tab" → check the actual width/height in pixels. - [ ] **52.** Add responsive srcset + sizes so mobile downloads small variants - How: Generate multiple sizes of each image: 400w, 800w, 1200w, 1600w (and 2000w for hero). · Use the srcset attribute on <img> : <img srcset="image-400.jpg 400w, image-800.jpg 800w, image-1200.jpg 1200w, image-1600.jpg 1600w" sizes="(max-width: 600px) 100vw, (max-width: 1200px) 50vw, 800px" src="image-1200.jpg" alt="..."> · The sizes attribute tells the browser how wide the image will be displayed at different viewport widths. The browser picks the closest source. · For WordPress, this is automatic since 4.4. For custom sites, implement it manually or use a library. - Avoid: Using srcset without sizes (browser assumes 100vw, downloads the largest) · Wrong sizes values (claiming 50vw when it's really 25vw downloads an unnecessarily large image) · Not generating enough size variants (a 4-size srcset is usually enough) - Verify: On a 360px phone, open a page with images. The image request should be the 400w or 800w variant, not the 1600w. · DevTools → Network → check the actual size downloaded for each image. - [ ] **53.** Set explicit width/height (or CSS aspect-ratio) on every image, iframe, and ad slot to kill CLS - How: For images: include width and height in the HTML: <img src="..." width="1600" height="900" alt="..."> · For iframes: same. <iframe width="640" height="360" src="..."> · For ad slots: reserve space in CSS. .ad-slot { min-height: 250px; } · For embedded widgets: reserve height before they load. · For modern CSS, you can use aspect-ratio: 16/9 instead of explicit dimensions on a wrapper. Either approach works. - Avoid: Using CSS width: 100% without aspect-ratio on the container (image loads, container resizes, layout shifts) · Loading fonts without size-adjust or font-display: optional (text reflows when the font loads) · Injecting content above existing content (banner appears, page jumps down) - Verify: Run PageSpeed Insights. "Cumulative Layout Shift" should be under 0.1. · Watch a slow 3G throttled load of your page. No visible content should shift as the page renders. - [ ] **54.** Add loading="lazy" to all below-the-fold images/iframes; NEVER lazy-load the LCP image - How: For every image that's not in the initial viewport: <img src="..." loading="lazy" width="..." height="..." alt="..."> · For every iframe (YouTube, ads, embedded content): same attribute. · For the LCP image (the first big image, usually the hero): do NOT add loading="lazy" . Loading=lazy defers the image, which delays LCP. · Browsers have a built-in lazy loading heuristic. loading="lazy" makes it explicit and starts the load earlier (before the user scrolls to it). - Avoid: Lazy-loading the LCP image (defeats the optimization — LCP is delayed) · Lazy-loading above-the-fold images (saves nothing, defers visible content) · Not lazy-loading below-fold iframes (wasteful — YouTube videos eat 500KB+ per embed) - Verify: Open a long page. The LCP image (first big image) should load immediately. Images below the fold should load on scroll. · DevTools → Network. Filter images. Watch which load when. - [ ] **55.** Add fetchpriority="high" to the LCP image and <link rel="preload"> it - How: Identify your LCP image. Use PageSpeed Insights or Chrome's Performance tab. Usually it's the hero image or the first big content image. · Add a preload link in your HTML head: <link rel="preload" as="image" href="/hero.avif" imagesrcset="/hero-400.avif 400w, /hero-800.avif 800w, /hero-1600.avif 1600w" imagesizes="100vw"> · If you have srcset and sizes, include them in the preload. The browser uses these to pick the right variant. · Don't preload more than one image. Preloading multiple images dilutes the priority and can hurt performance. - Avoid: Preloading the wrong image (preload the LCP image, not the most prominent) · Preloading multiple images (defeats the priority signal) · Preloading without srcset (forces a single size even on small viewports) - Verify: DevTools → Network. The preloaded image should appear with priority "High" in the network waterfall. · Re-run PageSpeed Insights. LCP should improve. - [ ] **56.** Self-host fonts (WOFF2), subset to used glyphs, set font-display: swap, and preload the primary font - How: For the LCP image: <img src="..." fetchpriority="high" width="..." height="..." alt="..."> · For the preload link: <link rel="preload" as="image" href="/hero.avif" fetchpriority="high"> · Use fetchpriority only for the single most important image on the page. Don't put it on every image. · Currently supported in Chrome, Edge, Opera. Firefox and Safari have it under different attributes or pending. - Avoid: Using fetchpriority on every image (the priority signal becomes noise) · Using fetchpriority on non-LCP images (browser already prioritizes correctly) · Not also using preload (fetchpriority and preload are complementary, not substitutes) - Verify: DevTools → Network. The image with fetchpriority should appear first in the network waterfall for that page. - [ ] **57.** Minify HTML, CSS, and JS (build-step: esbuild/terser/cssnano or server module) - How: Identify your critical CSS. Use a tool like critical or Addy Osmani's critical to extract the CSS used in the first viewport. · Inline it in your HTML: <head> <style>/* critical CSS here, ~5-15KB */</style> <link rel="preload" href="/main.css" as="style" onload="this.rel='stylesheet'"> <noscript><link rel="stylesheet" href="/main.css"></noscript> </head> · The main stylesheet loads async (the preload + onload trick), but the critical styles are already applied. · For a fully managed approach, Next.js does this automatically. Astro has the inlineStylesheets: 'auto' config. - Avoid: Inlining all CSS (huge HTML, defeats the purpose) · Inlining wrong CSS (e.g., styles for components that aren't in the first viewport) · Forgetting the noscript fallback (users with JS disabled see unstyled content) - Verify: DevTools → Network. The CSS file should load with low priority (after the HTML renders). · Disable JS. The page should still be styled (via the noscript fallback). - [ ] **58.** Inline critical/above-the-fold CSS; load the rest with media/async pattern - How: For scripts that don't need to run before the page renders: <script src="/analytics.js" defer></script> <script src="/ads.js" async></script> · Use defer when script order matters (e.g., jQuery + a plugin). defer preserves order. · Use async when order doesn't matter (analytics, ads, tracking pixels). async starts the download immediately and runs whenever the script is ready. · For framework-loaded scripts, set the framework's script tag to defer/async in your build config. - Avoid: Using defer on a script that needs to run before the page renders (e.g., a polyfill that must execute before the rest of the JS) · Using async when order matters (jQuery loads before plugin if both async — broken) · Putting scripts in the head without defer/async (blocks HTML parsing) - Verify: DevTools → Network. Scripts should not block HTML parsing. The waterfall should show HTML parsing complete before scripts run. · Run PageSpeed Insights. "Render-blocking resources" should not list your JS files. - [ ] **59.** Defer or async all non-critical JS; move <script> out of the render path - How: List every third-party script on your site. Check your <script src> tags and your tag manager (GTM, Tealium, etc.). · For each, ask: What does it do? Is it critical? · How many KB does it add? · Can it be loaded lazily (after page render)? · Can it be self-hosted (faster than the third-party CDN)? · Is there a lighter alternative? · · Common candidates for removal: Multiple analytics tools (you probably only need one) · A/B testing scripts that run by default on every page · Chat widgets that load 200KB of JS for a 5KB feature · Social sharing widgets (use simple links instead) · · For scripts you keep, load them async or after page load. window.addEventListener('load', () => { /* load script */ }) - Avoid: Keeping a script because "we might need it someday" (every KB hurts) · Adding scripts via a tag manager without auditing (tag managers are where script bloat lives) · Not measuring impact before/after (always test changes) - Verify: DevTools → Network. Sort by transfer size. Anything over 50KB from a third party is worth investigating. · Use Request Map or a similar tool to visualize all requests on a page. - [ ] **60.** Tree-shake/code-split JS; remove unused libraries and duplicate polyfills - How: Download the font files (woff2) you need. From Google Fonts or wherever you license them. · Place them in your site's /fonts/ directory. · Add @font-face declarations: @font-face { font-family: 'Inter'; src: url('/fonts/inter-var.woff2') format('woff2-variations'); font-weight: 100 900; font-display: swap; } · Set Cache-Control headers to cache fonts for a year. They're versioned in the URL when you update, so cache-busting is automatic. · Use font-display: swap to show fallback text immediately, swap to the real font when it loads. (Or optional if layout shifts are critical.) - Avoid: Loading more font weights than you actually use (each weight is a separate file) · Not using font-display: swap (text is invisible until the font loads) · Not setting long Cache-Control headers (fonts re-download on every visit) - Verify: DevTools → Network. Filter by font. The font request should be to your domain, not fonts.gstatic.com. · Verify the font is cached. Reload the page. The font request should be "from disk cache." - [ ] **61.** Purge unused CSS (PurgeCSS/UnoCSS) per template - How: Generate a Latin-only subset. With pyftsubset from fontTools: pyftsubset Inter-Variable.woff2 --output-file=inter-latin.woff2 --flavor=woff2 --unicodes=U+0020-007F,U+00A0-00FF · For multi-language sites, generate a Latin + Extended subset. For Chinese/Japanese/Korean sites, this is more complex (consider per-script fonts). · Use variable fonts where possible. A variable font contains all weights (100-900) in one file. Fixed-weight files are needed only when the variable font isn't supported (older Android). · Reference the subsetted file in @font-face. - Avoid: Loading the full font when you only need Latin (wastes 70% of the bytes) · Using multiple fixed-weight files when one variable font would do · Subsetting too aggressively (missing characters in user content) - Verify: Check the woff2 file size. Latin-only Inter should be ~50KB. Full Inter is ~300KB. · Use Wakamai Fondue to see which characters are in your font. - [ ] **62.** Enable Brotli (fallback Gzip) compression for text assets - How: In your @font-face: @font-face { font-family: 'Inter'; src: url('/fonts/inter.woff2') format('woff2'); font-display: swap; } · Choose between swap and optional : swap : always show the fallback immediately, swap when the font loads. Causes a brief layout shift. · optional : the browser decides. If the font loads fast enough, use it. Otherwise, stick with the fallback. No layout shift. · fallback : ~100ms invisible, then fallback, then swap when font loads. Compromise. · block : invisible until the font loads (3s max). Don't use unless you really need the font to render correctly for branding. · · For most content sites, swap is the right choice. For above-the-fold headlines, consider optional . - Avoid: Not specifying font-display (defaults to auto, browser behavior varies) · Using block (users see invisible text for up to 3s) · Loading fonts that take longer than the budget allows (use a faster CDN or self-host) - Verify: DevTools → Network. Throttle to "Slow 3G." Reload. You should see fallback text immediately, then swap. · Check for layout shift (CLS) when the font loads. - [ ] **63.** Set Cache-Control: public, max-age=31536000, immutable on fingerprinted static assets - How: Identify the third-party origins you connect to: fonts (if not self-hosted), analytics, CDN, ad networks. · Add preconnect hints in your HTML head: <link rel="preconnect" href="https://fonts.googleapis.com"> <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin> <link rel="preconnect" href="https://www.google-analytics.com"> · Use crossorigin for origins serving fonts, scripts, or other CORS-required resources. · Don't preconnect to origins you don't actually use. Each preconnect consumes resources. · Modern alternative: <link rel="preconnect" href="..."> can be replaced with <link rel="dns-prefetch" href="..."> for origins where you only need DNS resolution (less impactful but cheaper). - Avoid: Preconnecting to too many origins (browser limits concurrent connections) · Preconnecting without crossorigin for CORS-required resources (no benefit) · Not removing preconnects when you stop using a service (dead hints) - Verify: DevTools → Network. Look at the "Connection Start" timing. The TLS handshake should start before the request is made (preconnect worked). · Don't add more than 4-6 preconnects. Beyond that, the browser ignores them. - [ ] **64.** Serve all static assets (img/css/js/fonts) from a CDN with HTTP/2 or HTTP/3 - How: Check if your server uses Brotli. In nginx: brotli on; brotli_comp_level 6; brotli_types text/plain text/css application/json application/javascript text/xml; · Or for Apache with mod_brotli: <IfModule mod_brotli.c> AddOutputFilterByType BROTLI_COMPRESS text/html text/css application/javascript </IfModule> · For Cloudflare and most CDNs, Brotli is on by default. Verify in the response headers: content-encoding: br . · Don't compress already-compressed formats (images, video, fonts). The brotli_types directive above only enables for compressible types. - Avoid: Using compression level 11 (slow, no meaningful gain over 6) · Forgetting to enable for HTML responses (the biggest wins are on HTML) · Compressing small files (<1KB, the overhead exceeds the gain) - Verify: DevTools → Network. Look at the "Content-Encoding" header. Should be br for text responses. · Compare file sizes: a gzipped HTML vs brotli HTML should show ~15-20% smaller with brotli. - [ ] **65.** Add <link rel="preconnect"> + dns-prefetch for critical third-party origins - How: For static assets in nginx: location ~* \.(js|css|png|jpg|jpeg|gif|svg|woff2|webp|avif)$ { expires 1y; add_header Cache-Control "public, max-age=31536000, immutable"; } · For static assets served from a CDN (Cloudflare, Fastly, etc.), the CDN usually sets these headers. Verify. · For HTML responses, use short caching: Cache-Control: no-cache, must-revalidate . This forces the browser to revalidate but allows conditional 304 responses. · For service worker caching or PWA, configure separately. This is for the basic HTTP cache. - Avoid: Caching HTML for a year (users get stale pages) · Not using immutable on versioned assets (browsers may re-validate unnecessarily) · Caching without versioning (changing the file doesn't invalidate the cache) - Verify: DevTools → Network. Reload a page. Static assets should show "from disk cache" or "(memory cache)." · Check the Cache-Control header. Should include max-age=31536000 for static assets. - [ ] **66.** Lazy-load or facade third-party embeds (YouTube, chat, maps) until interaction - How: Measure TTFB. Check DevTools → Network → Timing on a few pages. Or use WebPageTest . · Optimize at the layer that's slow: Slow database: add indexes, optimize queries, add caching · Slow application: profile, cache responses, use async workers for slow tasks · Slow network: use a CDN, move closer to users · · For WordPress, common fixes: install a page cache (WP Super Cache, W3 Total Cache), use object cache (Redis), optimize the database. · For static sites or SSG, TTFB is usually fast. If not, check your hosting. · Edge rendering: serve HTML from the edge (Cloudflare Workers, Vercel, Netlify Edge). TTFB becomes ~50ms globally. - Avoid: Focusing on TTFB before fixing other things (TTFB matters but a 1.5s LCP is rarely fixed by TTFB alone) · Adding caching that doesn't actually cache (cache-busting headers, no cache key) · Database queries in a hot path that can be cached (auth, permissions lookups) - Verify: Run WebPageTest from 3 locations. TTFB should be under 200ms in your primary market. · For dynamic pages, profile the slow path with a tool like New Relic or your APM. - [ ] **67.** Audit and remove/limit heavy tag-manager and analytics scripts blocking main thread - How: Identify candidates for edge rendering: HTML pages that depend on a small amount of dynamic data (auth state, geo, A/B variant) · API responses that need personalization but not full SSR · Middleware (auth checks, redirects, header injection) · · Move the rendering to the edge. Cloudflare Workers example: export default { async fetch(request, env) { const url = new URL(request.url); if (url.pathname.startsWith('/api/')) { return handleApi(request, env); } return handlePage(request, env); } }; · Cache aggressively at the edge. Use Cache API for HTML responses, KV for data lookups. · Watch for edge-runtime limitations: no Node.js APIs, limited execution time, limited memory. - Avoid: Moving everything to the edge (some things are still better in the origin — heavy DB queries, large file processing) · Not caching at the edge (defeats the purpose — every request hits the origin) · Forgetting about edge runtime constraints (Node.js code won't run) - Verify: Test from multiple locations with WebPageTest. TTFB should be under 100ms in major markets. · Monitor cold start times. Edge functions can have a few-ms cold start on first request. - [ ] **68.** Cut TTFB <200ms via server cache / edge caching / static generation - How: Choose SSR over CSR for content pages. Next.js, Nuxt, SvelteKit, Astro all default to SSR or static generation for content. · Use static generation (SSG) when content doesn't change per-request. Build the HTML at deploy time. Fastest possible TTFB. · Use SSR for per-request content. Render the HTML on the server with the user's data. · Use ISR (Incremental Static Regeneration) for content that changes periodically. Best of both: served from cache, revalidated on schedule. · For client-rendered apps, consider hydration on top of SSR (the user gets content immediately, interactivity comes a few hundred ms later). - Avoid: CSR for SEO-critical content (homepage, blog posts, product pages) · SSR for content that doesn't need it (a static page rendered on every request wastes CPU) · Not using streaming (with React 18 server components or similar, the HTML can stream as it's generated) - Verify: View source on your key pages. The main content should be in the HTML, not loaded after JS. · Disable JS in DevTools and reload. The content should still be visible (SSR proof). - [ ] **69.** Get LCP <2.5s (field, 75th percentile) — measure in CrUX/PageSpeed Insights, not just lab - How: Profile hydration time. Chrome DevTools → Performance → look for "Long Task" warnings during page load. Hydration is often a culprit. · Use partial hydration where possible. Astro and Qwik both ship zero JS by default, only hydrating islands that need interactivity. · For React, use Server Components to avoid sending component code to the client. Only interactive parts hydrate. · For Vue/Nuxt, use lazy hydration: <LazyHydrate :when-visible="true"> · Defer non-critical hydration. Interactive features (modals, dropdowns) can hydrate on demand rather than on page load. - Avoid: Hydrating the entire page when only a few parts need interactivity (most static text doesn't need to be interactive) · Hydrating synchronously and blocking the main thread (causes INP spikes) · Hydrating before the main content is visible (slower LCP) - Verify: DevTools → Performance. Hydration should not produce a Long Task (over 50ms). · Test INP. The page should be interactive within 200ms of the user trying to interact. - [ ] **70.** Get CLS <0.1 — reserve space for fonts, images, ads, and injected banners - How: For icons, use an SVG sprite. A single icons.svg file with <symbol> elements, referenced via <use href="#icon-name"> . · For decorative images, individual files are fine. HTTP/2 handles multiple requests efficiently. · For above-the-fold images that are critical, preload them (see action #55). Don't sprite them — preloading a sprite is wasteful. · If you have a legacy sprite, you can keep it, but don't add new ones. - Avoid: Creating a new CSS sprite in 2026 (use SVG sprites or individual SVGs) · Using a single huge image with CSS background positioning (legacy technique, mostly obsolete) · Preloading an entire sprite (forces download of all icons even if only one is used) - Verify: If you have a legacy sprite, the file should be under 50KB total. Most modern sites don't need them at all. - [ ] **71.** Get INP <200ms — break up long tasks, debounce handlers, avoid heavy JS on interaction - How: For icons and small graphics, paste the SVG markup directly into the HTML: <button> <svg width="20" height="20" viewBox="0 0 20 20"> <path d="M..."></path> </svg> Click me </button> · Inline SVG is cacheable as part of the HTML, renderable without waiting for an external file, and stylable with CSS. · For repeated icons across the site, use SVG sprites instead (see action #70). · Don't inline large SVGs (over 5-10KB). At that size, a separate file with caching is better. - Avoid: Inlining huge SVG files (the HTML becomes massive) · Inlining the same SVG 50 times on a page (use a sprite or single source) · Not optimizing the SVG (use SVGO to remove unnecessary paths, comments, metadata) - Verify: Run SVGO on your SVGs. They should typically shrink 30-60%. · Total SVG inline size per page should be under 10KB for most pages. - [ ] **72.** Eliminate render-blocking resources reported in PSI Opportunities - How: Measure the critical rendering path. DevTools → Performance → look at "First Contentful Paint" and "Largest Contentful Paint" markers. · Identify the bottleneck. Usually one of: Slow TTFB (server taking too long) · Large render-blocking CSS (critical CSS not inlined) · Large render-blocking JS (defer or async not set) · Large LCP image (image is the bottleneck) · · Fix the dominant bottleneck. Often the LCP image is the highest-leverage fix. · Re-measure. The CWV should improve. - Avoid: Optimizing everything at once (can't tell what's working) · Optimizing the wrong bottleneck (e.g., LCP is slow because of TTFB, not because of image size) · Ignoring the critical path entirely (fixing small things, missing the big ones) - Verify: Use PageSpeed Insights' "Opportunities" section. Each opportunity is a fix for one part of the critical rendering path. · Test in Chrome DevTools with throttling enabled. The waterfall should show HTML → CSS → image → LCP, with minimal time between them. - [ ] **73.** Add resource hints (preload for hero, prefetch for likely next page) - How: Add to below-the-fold sections: .below-fold { content-visibility: auto; contain-intrinsic-size: 0 500px; /* estimated height */ } · The contain-intrinsic-size is critical — without it, the scrollbar will jump when the section renders. · Use content-visibility: hidden to completely defer rendering of a section that may never be visible. · Modern browser support: Chrome 85+, Edge, Opera. Firefox has it under a flag or in newer versions. Safari support is partial. · For Safari/Firefox fallback, the CSS rule is ignored (no harm done). - Avoid: Forgetting contain-intrinsic-size (causes scrollbar jumping) · Using on above-the-fold content (defeats the purpose — it should render immediately) · Setting a too-large contain-intrinsic-size (wastes vertical space) - Verify: DevTools → Performance. The "Rendering" phase should be much faster for below-fold sections. · Run PageSpeed Insights. TBT (Total Blocking Time) should drop. - [ ] **74.** Compress and lazy-init above-average DOM (<1,500 nodes); flatten deep nesting - How: Identify long tasks. DevTools → Performance → look for tasks with red triangles (Long Task warnings). · For each long task, break it up: Use setTimeout(fn, 0) to yield to the browser · Use requestIdleCallback() for non-critical work · Use scheduler.yield() (newer API) for better scheduling · Use Web Workers for CPU-intensive work (parsing, image processing) · · Reduce JS payload. Smaller JS = less to parse and execute: Code-split with dynamic imports · Tree-shake unused code · Use modern build tools (esbuild, swc, Vite) for faster parsing · · For frameworks, use the production build (not dev). Production has minification, dead code elimination, etc. - Avoid: Using setTimeout(fn, 0) for everything (causes flash of unstyled content or other UX issues) · Importing a whole library for one function (e.g., importing lodash for _.get ) · Not profiling before optimizing (guessing what's slow) - Verify: DevTools → Performance. Confirm no Long Tasks (over 50ms) on page load or interaction. · Use the Performance Observer API to track INP in the field: new PerformanceObserver(list => ...) - [ ] **75.** Enable image CDN auto-format/auto-quality if available (serve AVIF to supporting browsers) - How: Identify work that can be moved off the main thread: Image processing (filtering, resizing, format conversion) · Parsing large data (JSON, CSV, XML) · Complex calculations (data analysis, encryption) · Generating large HTML strings for client-side rendering · · Create a worker: // worker.js self.onmessage = (e) => { const result = heavyComputation(e.data); self.postMessage(result); }; // main.js const worker = new Worker('/worker.js'); worker.postMessage(data); worker.onmessage = (e) => { updateUI(e.data); }; · For modern frameworks, use a worker-loader (Webpack, Vite) or a library like Comlink to make the API simpler. - Avoid: Using workers for trivial work (the overhead exceeds the gain for small tasks) · Not handling errors and timeouts (a worker that hangs blocks the feature) · Sending large data structures (workers can only send structured-cloneable data) - Verify: DevTools → Performance. With workers, the main thread should have no Long Tasks from the heavy computation. · Verify the worker is actually running. Chrome DevTools → Sources → Workers. - [ ] **76.** Cache API/HTML at the edge; use stale-while-revalidate for dynamic-but-stable pages - How: For YouTube embeds, use the loading="lazy" attribute on the iframe: <iframe loading="lazy" src="https://www.youtube.com/embed/..."></iframe> · Better: use a "lite" YouTube embed. Load a placeholder image of the video, replace with the iframe on click: <div class="youtube-lite" data-id="VIDEO_ID"> <img src="https://i.ytimg.com/vi/VIDEO_ID/hqdefault.jpg" alt="..."> <button>▶</button> </div> · For Google Maps, use a static map image. Click to load the full interactive map. · For other embeds, use loading="lazy" or load on user interaction. - Avoid: Loading 5+ iframes on a page (each adds 500KB+ of JS) · Putting the iframe above the fold (defeats the LCP benefit) · Using autoplay (defeats the click-to-load pattern) - Verify: DevTools → Network. The iframe should load when scrolled into view, not on initial page load. · Compare LCP with and without the iframe. - [ ] **77.** Monitor Core Web Vitals in GSC → Core Web Vitals and PageSpeed Insights monthly; fix regressions - How: Check your server's HTTP version. In Chrome DevTools → Network → check the "Protocol" column. Should be "h2" for HTTP/2, "h3" for HTTP/3. · For nginx, enable HTTP/2: listen 443 ssl http2; · For HTTP/3, your CDN usually enables it. Cloudflare, Fastly, and most modern CDNs support QUIC. Verify it's on. · Remove old techniques you may still be using: Domain sharding (split assets across subdomains) — hurts with HTTP/2 · File concatenation (single combined JS/CSS file) — not needed with HTTP/2 multiplexing · Image sprites — not needed for HTTP/2 - Avoid: Staying on HTTP/1.1 (older servers still default to this) · Keeping domain sharding (now a performance penalty) · Not using HTTPS (HTTP/2 requires it, and HTTP/3 does too) - Verify: DevTools → Network → Protocol column. Should be h2 or h3. · Use KeyCDN HTTP/2 test to verify. - [ ] **78.** Remove layout-shifting late-loading elements (cookie bars, "you may also like", auto-injected ads) - How: For a basic caching service worker: // sw.js const CACHE = 'v1'; const ASSETS = ['/', '/css/main.css', '/js/main.js']; self.addEventListener('install', (e) => { e.waitUntil(caches.open(CACHE).then(c => c.addAll(ASSETS))); }); self.addEventListener('fetch', (e) => { e.respondWith( caches.match(e.request).then(r => r || fetch(e.request)) ); }); · Register from your main JS: if ('serviceWorker' in navigator) { navigator.serviceWorker.register('/sw.js'); } · For more sophisticated strategies, use Workbox (Google's library). Stale-while-revalidate is a good default for most assets. · Don't break things. Always have a fallback to network. Test offline behavior. - Avoid: Caching HTML for too long (users see stale content) · Not handling the install/activate lifecycle correctly (old service workers persist) · Caching user-specific data in a shared cache (privacy issue) - Verify: Chrome DevTools → Application → Service Workers. Should show your worker as "activated and running." · Reload the page. The second load should be much faster (cached resources). ## E · Mobile _9 actions, #79–87_ Google indexes the mobile version of your site. If content, links or structured data exist only on desktop, they effectively do not exist. - [ ] **79.** Serve one responsive layout; verify it passes GSC mobile usability with no horizontal scroll - How: Add this to every page's <head> : <meta name="viewport" content="width=device-width, initial-scale=1"> · For most sites, this is enough. Don't add user-scalable=no or maximum-scale=1 — these prevent users from zooming, which is an accessibility issue. · For PWA support, add viewport-fit=cover and use env(safe-area-inset-*) CSS for the iPhone notch. · Verify: open the page on a real phone (or Chrome DevTools mobile emulator). The text should be readable without zooming. - Avoid: Forgetting the viewport tag entirely (text is microscopic on mobile) · Using a fixed width like width=1024 (forces horizontal scrolling on phones) · Disabling user zoom ( user-scalable=no ) — accessibility failure - Verify: View source on a page. The viewport meta tag should be present. · Open on mobile. Text should be readable. The page should fit the screen width without horizontal scroll. - [ ] **80.** Ship IDENTICAL primary content + structured data + links on mobile and desktop (mobile-first index) - How: Open your site on a real phone (or DevTools mobile emulator at 360px width). · Look for any horizontal scroll. If the page scrolls left/right, something is too wide. · Identify the culprit. DevTools → Elements → look for elements with computed width > viewport width. · Common fixes: Images: add max-width: 100%; height: auto; · Tables: wrap in a scrollable container or use responsive table CSS · Code blocks: overflow-x: auto; · Long URLs: word-break: break-word; · · Set overflow-x: hidden on body as a last resort (hides the problem without fixing it). - Avoid: Fixed-width elements (a 1200px hero image, a 500px-wide embed) without responsive styles · Forgetting to test on real devices (desktop testing hides mobile issues) · Using overflow-x: hidden as the only fix (just hides the scroll, content is still cut off) - Verify: Open on 360px viewport. Page should not scroll horizontally. · DevTools → Lighthouse → ensure no horizontal scrolling warning. - [ ] **81.** Set <meta name="viewport" content="width=device-width, initial-scale=1"> - How: Audit your key interactive elements: Navigation links: 48px tall minimum · Buttons (CTA, form submit): 48×48 minimum · Form inputs: 48px tall (16px font size too, prevents iOS zoom) · Icon buttons: 48×48 tap area (use padding to expand the tap zone) · · Add tap target padding without changing the visual size: .icon-button { width: 24px; height: 24px; padding: 12px; /* expands tap zone to 48×48 */ margin: -12px; /* keeps visual position */ } · For lists of links (like related posts), ensure vertical spacing between links is at least 8px. · Use Chrome DevTools → Inspect → check the rendered tap target size. - Avoid: Visual 24px icons with no padding (24×24 tap target) · Text links with no padding inside a paragraph (tap target is just the text height, not the line height) · Adjacent links in a list with no spacing (mis-tap constantly) - Verify: Chrome DevTools → Audit → "Tap targets are sized appropriately" — should pass. · Test on a real phone. Tapping each link/button should not require precision. - [ ] **82.** Make tap targets ≥48×48px with ≥8px spacing - How: Set body font size: body { font-size: 16px; line-height: 1.5; } · For mobile-specific sizes: @media (max-width: 600px) { body { font-size: 17px; } /* slightly larger on mobile */ } · Headings scale up: h1 { font-size: 2rem; } (relative to body). Never use absolute sizes smaller than 12px. · For specific UI elements (badges, captions), 14px is the lower limit. 12px is acceptable only for legal text. - Avoid: Setting body font-size to 14px (causes iOS zoom, hard to read) · Using pixel sizes for headings (defeats accessibility scaling) · Setting small text on hero sections (tries to look "designed," fails on mobile) - Verify: DevTools → Lighthouse → "Document doesn't use legible font sizes" — should pass. · Open on iPhone. Tap a form input. Page should not zoom. - [ ] **83.** Remove full-screen interstitials/pop-ups that cover content on mobile load (leak: MobileInterstitials demotion) - How: Identify any modal/overlay that covers the main content on page load. · Replace with: A small banner at the top or bottom (not full-screen) · An inline CTA within the content · A modal that requires user action (click) to appear, not auto-load · · If you need a cookie consent banner, use a small bottom bar (not full-screen overlay). · If you need an app-install prompt, defer it until the user has been on the site for a while and shown engagement (e.g., scrolled, visited 2+ pages). · Google's specific penalty: full-screen interstitials that the user must dismiss before accessing the main content. Avoid these entirely. - Avoid: Full-screen "subscribe to our newsletter" modal on first visit (Google penalty + user frustration) · Cookie consent that covers the whole page (legal requirement, but should be a small banner) · App install banner that takes 30%+ of viewport on mobile - Verify: Open the site on a phone. No full-screen overlay should appear automatically. · DevTools → Lighthouse → "Avoids intrusive interstitials" — should pass. - [ ] **84.** Remove intrusive desktop interstitials on landing pages too - How: Start with the mobile design. Sketch or wireframe at 360px width first. · For each element, ask: "Is this essential?" If not, hide it on mobile or move it to a secondary screen. · Add complexity as the screen grows: /* Base = mobile */ .nav { /* single column, hamburger */ } /* Tablet+ */ @media (min-width: 768px) { .nav { /* full nav row */ } } /* Desktop+ */ @media (min-width: 1024px) { /* maybe wider spacing, side-by-side layouts */ } · Touch targets must work without hover (no tooltips, no hover-only menus). · Test on real phones throughout the design process, not just at the end. - Avoid: Designing desktop first, then trying to "cram down" (cluttered mobile) · Using hover-only navigation (doesn't work on touch) · Assuming "mobile users want less" (they want the same content, just presented differently) - Verify: Open the site on a phone. Every important feature should be accessible without zooming or horizontal scrolling. · Compare mobile vs desktop: mobile should be a curated version of the same content, not a stripped-down shell. - [ ] **85.** Ensure body text ≥16px on mobile; no pinch-zoom required to read - How: Don't implement AMP unless you have a reason (news publishing for Top Stories carousel, very slow hosting you can't fix). · If you have legacy AMP pages, migrate them to regular HTML pages with proper mobile optimization. Google supports this migration. · Remove AMP-specific code from your CMS or templates if it exists. · For mobile performance, focus on the standard Core Web Vitals optimizations (see Section D). - Avoid: Implementing AMP in 2026 "for SEO" (no SEO benefit, adds complexity) · Maintaining AMP pages when you could have a single, fast, mobile-friendly site · Using AMP's analytics and ad restrictions (you're locked into their ecosystem) - Verify: Check your pages: any AMP-specific markup? Any <html amp> tags? If yes, plan a migration. · Compare your mobile CWV scores with non-AMP versions. If AMP isn't winning by a large margin, drop it. - [ ] **86.** Don't hide key content behind mobile-only accordions Google may weight less; keep it in the DOM - How: Open GSC → Experience → Mobile Usability. See which pages have issues. · For each issue type: "Text too small to read" — increase font size, especially for body text · "Clickable elements too close together" — increase tap target padding · "Content wider than screen" — fix elements that overflow · "Viewport not set" — add the viewport meta tag (see action #79) · · For each affected URL, fix the issue then click "Validate Fix" in GSC. · Re-check in 1-2 weeks. Google needs to recrawl to confirm. - Avoid: Ignoring the report (mobile usability is a small ranking factor; not catastrophic but easy to fix) · Trying to fix all issues at once (validate one URL type at a time to track what works) · Not retesting after the fix (you'll never know if it worked) - Verify: GSC → Mobile Usability. Issue count should drop to 0 after fixes. · Test on a real phone. The reported issues should be visually fixed. - [ ] **87.** Test the real mobile page speed on throttled 4G (PSI mobile tab), not just desktop - How: For a basic PWA: A manifest.json with name, icons, start_url, display · A service worker that caches resources for offline use · HTTPS (required for service workers) · · For installation prompts, follow the criteria: The app is loaded over HTTPS · The user has engaged with the site (visited 2+ times, 5+ minutes between visits) · A valid manifest.json is linked from every page · · For push notifications, ask for permission in context (not on first visit). Don't abuse them — push notifications that aren't valuable get blocked. - Avoid: Implementing PWA for SEO (no ranking benefit) · Aggressive install prompts (users dismiss or block your site) · Push notifications for low-value content (users turn them off, hurting engagement metrics) · Forgetting to test offline mode (PWA without offline support is just a regular site with a service worker overhead) - Verify: Chrome DevTools → Application → Manifest. Should validate. · Disable network. The site should still load (cached version). · On Android Chrome, after 2 visits, the install prompt should appear (if criteria met). ## F · On-page HTML _22 actions, #88–109_ Titles, headings, meta descriptions, the elements a crawler reads first and a searcher reads in the results page. Small edits, immediate effect, entirely within your control. - [ ] **88.** Write one unique <title> per page: pattern Primary Keyword | Modifier — Brand - How: Title tag format: <title>Primary Keyword - Modifier

for structural regions · · Don't use headings to style text. Use CSS classes. · Don't use display:none or visibility:hidden to hide content from users (Google may ignore it for ranking). · Validate your HTML with the W3C validator. - Avoid: Using

instead of

(Google may not see it as a heading) · Skipping heading levels · Using multiple H1s on a page · Hidden text for SEO (penalty risk) - Verify: Crawl with Screaming Frog. Check heading hierarchy. Should be valid (no skipped levels, one H1). · Validate HTML at W3C validator . - [ ] 94. Nest H2/H3 logically (no skipped levels); put secondary keywords/questions in H2s - How: For every internal link in the body, ask: "Does the anchor text describe the destination?" · Good examples: "Learn more about XML sitemaps " — anchor text is the topic · "See our guide to canonicalization " — descriptive, useful · · Bad examples to avoid: " Click here for more" — generic · " Read this article " — vague · " https://yoursite.com/article " — URL as anchor text · · Don't over-optimize. The anchor should read naturally in the sentence. Forcing exact-match anchors looks manipulative. - Avoid: Using "click here" or "read more" universally · Over-optimizing anchors (every link to /sitemap uses "sitemap" — looks like a pattern) · Forgetting alt text on image links (alt text is the anchor for screen readers and Google Images) - Verify: Sample 10 pages. For each internal link in the body, check the anchor text. Is it descriptive? · Crawl with Screaming Frog → "All" → "Anchor Text" filter. Look for generic anchors. - [ ] 95. Phrase 2–4 subheadings as the exact "People Also Ask" questions to win snippets - How: Keep paragraphs short. 2-4 sentences max. A wall of text is unreadable. · Use subheadings every 200-300 words. They give readers a way to scan and skip to the parts they care about. · Use bullet lists and numbered lists for steps, options, or non-sequential items. · Use bold and italic for emphasis, but sparingly. Every other word in bold loses the effect. · Use images, diagrams, and tables to illustrate complex points. · For long pages, a table of contents at the top (with anchor links) helps readers navigate. - Avoid: 5-paragraph blocks with no breaks (kills scanability) · Subheadings every 50 words (no actual content between them) · No lists or visual elements (everything is paragraphs) · Bold on every third word (defeats the emphasis) - Verify: Read your own content. Can you skim it in 30 seconds and understand the structure? · Count paragraphs. Most should be under 4 sentences. - [ ] 96. Set body font-size ≥16px and adequate contrast; avoid tiny/hidden text (leak: DocumentStyleFontSize/GoodocFontSizeStats) - How: For each page that has language or regional variants, add hreflang tags in the : · Each variant page must reference ALL other variants AND itself (self-referential). · Use the official language codes (ISO 639-1) and optional region codes (ISO 3166-1): en-US , en-GB , fr-CA . · You can also specify hreflang in the XML sitemap instead of HTML head (better for large sites). - Avoid: Only specifying hreflang in one direction (A says "alternate fr-FR" but B doesn't say "alternate en") · Using wrong language codes (e.g., "uk" for Ukrainian vs "uk" for United Kingdom — use "ua" for the latter, or "uk-UA") · Forgetting the x-default tag (used when no other variant matches) · Returning 404 for hreflang-referenced URLs (Google treats as broken signals) - Verify: For each multi-language page, view source. Confirm hreflang tags are present and bidirectional. · Validate with hreflang validator . - [ ] 97. Place primary content above the fold; push ads/related below the first screen - How: Create a favicon at multiple sizes. Modern browsers prefer SVG or PNG. iOS wants 180×180, Android wants 192×192. · Add to your : · For SVG favicons, modern browsers can render them at any size. For older browsers, fall back to PNG. · For PWA, add a web manifest with icon definitions. - Avoid: No favicon (browser shows a generic icon) · Favicon at wrong size (blurry in tabs) · Favicon not optimized (huge ICO file) · apple-touch-icon missing (iOS home screen shortcuts use a default) - Verify: Open your site. Browser tab should show a sharp favicon. · Add to home screen on iOS. Should show the right icon. - [ ] 98. Use a descriptive, keyword-first URL slug (3–5 words); avoid dates/stop-words in the slug - How: For WordPress, RSS is automatic at /feed/ . Just add the link tag in your head: · For custom sites, generate an RSS or Atom feed: YourSite https://yoursite.com/ ... Article title https://yoursite.com/article Mon, 16 Aug 2026 12:00:00 GMT · Submit your feed to RSS aggregators and to Bing (Google no longer uses feed content for indexing). - Avoid: Feed with broken dates or invalid XML (readers reject it) · Feed missing full content (just excerpts, when the reader expects full) · No link from the site to the feed (users can't find it) · Feed not served with Content-Type: application/rss+xml - Verify: Open your feed URL in a browser. Should display as raw XML. · Validate with the W3C Feed Validator. · Test in an RSS reader (Feedly, Inoreader, NetNewsWire). - [ ] 99. Add a jump-link Table of Contents on posts >1,500 words (anchors help passage/snippet extraction) - How: For every form field, use a with a for attribute matching the input's id : Email · Use HTML5 validation ( required , type="email" , pattern ). Don't rely on JavaScript alone for validation. · Show validation errors inline, near the field, in plain language. · For accessibility, use aria-describedby for help text and aria-invalid="true" for fields with errors. · On submit, disable the button to prevent double-submit. Show a loading state. - Avoid: Placeholder as label (placeholder disappears when typing, leaving the field unlabeled) · Generic error messages ("Invalid input" — what was invalid?) · No keyboard support (can't tab through fields, can't submit with Enter) · Submitting with no feedback (user doesn't know if it worked) - Verify: Test the form with keyboard only (no mouse). Tab through fields. Submit with Enter. · Use a screen reader to navigate. Each field should be announced with its label. - [ ] 100. Bold/ the single direct answer sentence for each target question - How: Use tables only for tabular data (rows of related information, like a pricing comparison). · For layout, use CSS Grid or Flexbox. They're responsive, accessible, and semantic. · For data tables:
Pricing comparison

Plan Price

Basic $10/mo

· Use scope="col" and scope="row" for headers. Screen readers use this to associate cells with their headers. · For wide tables, wrap in a horizontally-scrollable container. - Avoid: Using for layout (cols and rows of arbitrary content) · No scope attributes on , ,
· Missing
(screen readers don't know what the table is about) · Inline styles instead of CSS (harder to maintain, harder to make responsive) - Verify: View source on a page with a table. Should have
, and
. · Test with a screen reader. Headers should be announced when navigating cells. - [ ] 101. Add descriptive alt on every content image (see Section O for spec) - How: Format: /parent-topic/child-topic/page-name . Hyphen-separated, lowercase, no special characters. · Include the primary keyword when natural: /seo/sitemap-guide not /articles/12345 . · Keep under 75 characters total. Over 100 looks spammy. · Don't change URLs once published. Each change requires a 301 redirect and loses some signal. · For WordPress, the post slug is editable. For Next.js, configure useRouter or your routing layer. · For dynamic content, generate slugs from titles: "How to Build Sitemaps" → /how-to-build-sitemaps - Avoid: Including the date in the URL ( /2026/08/16/post ) — forces a redirect or staleness · Using IDs ( /article/12345 ) — no information for users or Google · Underscores instead of hyphens (Google sees one word) · Uppercase letters (creates duplicate URLs) · Changing URLs without redirects - Verify: Sample 20 URLs. Each should be lowercase, hyphenated, under 75 chars. · For the primary keyword of each page, the slug should contain it (where natural). - [ ] 102. Add Open Graph (og:title/description/image 1200×630) + Twitter Card tags - How: Add id attributes to the target elements:
Installation

...
· Link to them with hash URLs: Jump to installation · For table of contents at the top of a long article, list all major sections with anchor links. · Style the anchor target on focus or with a subtle visual indicator so users know where they jumped to. · Test that the anchor scrolls smoothly (use scroll-behavior: smooth on the html element). - Avoid: Missing id on the target (link does nothing) · Duplicate id values (browser jumps to the first one) · Non-descriptive anchor text ("Click here for more") · No focus indicator (users don't know where they jumped) - Verify: Click an anchor link. The page should scroll to the right section. · Tab through the page. The current section should have a focus indicator. - [ ] 103. Include the target keyword + close synonyms in the first 100 words naturally - How: Append UTM parameters to your campaign URLs: https://yoursite.com/article?utm_source=twitter&utm_medium=social&utm_campaign=launch · On every page, the canonical tag should point to the URL WITHOUT UTM parameters: · Use a UTM builder to keep your parameters consistent. A typo ("utm_souce") creates a new campaign in your analytics. · Document your UTM conventions: which sources, which mediums, how to name campaigns. - Avoid: Not canonicalizing UTM URLs (Google indexes both with and without params as duplicates) · Inconsistent UTM values ("email" vs "Email" vs "newsletter" — three different campaigns in analytics) · Using UTMs for internal links (only use them for external campaign tracking) · Forgetting to test the canonical tag handles the params (a config bug in your CMS can break this) - Verify: Visit yoursite.com/article?utm_source=test . View source. The canonical should be yoursite.com/article (no params). · Check your analytics: campaigns should be properly attributed. - [ ] 104. Use structured formatting (lists, tables, definition blocks) that maps to snippet formats - How: For every , write descriptive alt text: · Make it specific. "A woman in a blue dress" is okay. "Jane presenting the Q3 results to the marketing team" is better — it adds context. · Keep under 125 characters (some screen readers cut off at this length). · Don't start with "image of" or "picture of" (screen readers already announce the image). · For decorative images (background, separator), use empty alt: alt="" . This tells screen readers to skip the image. · For images that contain text, include the text in the alt. - Avoid: Empty alt on non-decorative images (accessibility failure) · "image1.jpg", "IMG_29381.jpg", "untitled.png" (the filename is not alt text) · Keyword stuffing: "blue shoes, blue sneakers, blue footwear, blue shoes cheap" · Same alt text on every image (no information) · Including "image of" (redundant, screen readers already announce it) - Verify: Crawl with Screaming Frog. Check "Missing Alt Text" — should be 0 for non-decorative images. · Sample 10 images. Each should have descriptive, concise alt text. - [ ] 105. Keep keyword density natural; never repeat exact-match keyword unnaturally (spam signal) - How: When saving images, use a descriptive filename: blue-cotton-tshirt-2026.jpg , not IMG_29381.jpg . · Use hyphens, not underscores. Google treats hyphens as word separators. · Keep filenames short but descriptive. Under 50 characters. · Include the primary keyword when natural (don't force it). · Lowercase only. Mixed case creates inconsistent URLs. · For bulk image uploads, automate the renaming in your image processing pipeline. - Avoid: Default camera filenames (IMG_29381, DSC_0001, etc.) · Filenames with special characters or spaces (URL encoding issues) · Filenames longer than 100 characters (URL gets unwieldy) · Using the same filename for different images (the second overwrites the first in cache) - Verify: Crawl with Screaming Frog. The "Image Filename" column should be descriptive, not "IMG_" or "DSC_". · Manually rename any non-descriptive images. - [ ] 106. Ensure the visible H1 and the differ enough to cover two phrasings of intent - How: Add loading="lazy" to every image below the fold: <img src="..." loading="lazy" width="..." height="..." alt="..."> · The LCP image (first big image, usually hero) should NOT have loading="lazy". Loading=lazy defers the image, delaying LCP. · Set width and height to prevent CLS. · Browsers have a built-in lazy-loading heuristic (~2-3 viewport heights), so adding loading=lazy just makes it explicit and earlier. - Avoid: Lazy-loading the LCP image (defeats the optimization — LCP is delayed) · Lazy-loading above-the-fold images (saves nothing, defers visible content) · Not setting width/height (causes CLS when the image loads) - Verify: DevTools → Network. Below-fold images should not load on initial page load. · Open a long page. The LCP image should be the first to load. - [ ] 107. Add lang attribute on <html> and correct charset <meta> - How: Always set width and height on <img> : <img src="..." width="1600" height="900" alt="..."> · Width and height can be the original image dimensions. CSS scales the image to fit, but the aspect ratio is preserved. · For responsive images, you can also use CSS aspect-ratio on the container: .image-container { aspect-ratio: 16 / 9; width: 100%; } · For SVGs, set width and height on the <svg> element (not on a parent div). - Avoid: Missing width/height (causes layout shift when image loads) · Using CSS width: 100% without aspect-ratio (same problem) · Forgetting on iframes (they also cause CLS without dimensions) - Verify: DevTools → Lighthouse → "Image elements without width/height" — should pass. · Watch a slow load of your page. No visible content should shift as images render. - [ ] 108. Write scannable intros (≤3 sentences) stating what the page delivers - How: Use semantic table structure: <table> <caption>Pricing for 2026 plans</caption> <thead> <tr><th scope="col">Plan</th><th scope="col">Price</th><th scope="col">Features</th></tr> </thead> <tbody> <tr><th scope="row">Basic</th><td>$10/mo</td><td>5 pages</td></tr> <tr><th scope="row">Pro</th><td>$30/mo</td><td>Unlimited</td></tr> </tbody> </table> · The caption describes the table. Screen readers read it first. · Header cells ( <th> ) with scope tell screen readers (and Google) which cells are headers for which rows/columns. · Don't merge cells ( colspan , rowspan ) unless necessary. They confuse screen readers. - Avoid: Using <td> for headers (should be <th> ) · Missing scope attributes · Missing <caption> · Empty cells for visual spacing (use CSS padding instead) - Verify: Test with a screen reader. Each cell should announce its header. · Validate HTML structure. - [ ] 109. Use semantic HTML (<article>, <nav>, <main>, <section>) to clarify main content vs boilerplate - How: Choose a comment system: Disqus: easy, popular, but adds 100KB+ of JS · Native comments: full control, no third-party JS, but you handle spam · No comments: simpler, faster, but loses engagement signal · · Moderate before publishing. Pre-moderation prevents spam from going live. · Noindex comment URLs (usually ?replytocom= parameter URLs) to avoid duplicate content. · Use rel="nofollow ugc" on comment author links. This tells Google not to vouch for these links. · For SEO, the comment content should add value, not just be a link farm. - Avoid: Allowing unmoderated comments (spam, garbage content on your site) · Using dofollow on comment links (Google penalty risk) · Indexing ?replytocom= URLs (duplicate content) · Slowing the page with a heavy comment system (kills LCP) - Verify: Test the comment system. Does it work, is it fast, is it spam-free? · View source on a comment URL. Should be noindex. ## G · Content quality _24 actions, #110–133_ The part that cannot be automated into existence. Information gain over what already ranks, original data, first-hand experience, and a page that actually completes the visitor's task. - [ ] 110. Publish genuinely original content — no scraped, spun, or thin AI-generated pages (leak: OriginalContentScore, effort signals) - [ ] 111. Cover the topic more completely than the current top-10; match their subtopics + add missing ones - _Applies to the 2 actions above._ - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 112. Answer the primary query in the first 100 words, then go deep - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 113. Add first-hand experience: original photos, tests, screenshots, "we tried X" data (E-E-A-T "Experience") - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 114. Add original data/research/surveys or a proprietary framework — the strongest link + quality magnet - [ ] 115. Cite primary sources (studies, docs, official data) with outbound links to authoritative domains - _Applies to the 2 actions above._ - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 116. Show visible authorship: byline, author bio, credentials, publish + updated dates - [ ] 117. Delete or merge thin (<300-word, no-unique-value) pages; consolidate into comprehensive guides - _Applies to the 2 actions above._ - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 118. Remove/upgrade doorway, near-empty tag, and auto-generated archive pages - [ ] 119. Match each URL to exactly one search intent (informational vs commercial vs transactional) - [ ] 120. Add comparison tables for "X vs Y" and "best X" queries - _Applies to the 3 actions above._ - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 121. Add pros/cons blocks for review/decision content - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 122. Add an FAQ answering the top "People Also Ask" for the query - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 123. Keep ad density low; remove content-blocking pop-ups and mid-content ad clutter (leak: clutterScore) - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 124. Break text into short paragraphs (≤3 lines) + descriptive subheads for scannability - [ ] 125. Fix grammar/spelling/readability; aim for the audience's reading level - _Applies to the 2 actions above._ - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 126. Add supporting media every ~300 words: original images, charts, diagrams, or embedded video - How: Run PageSpeed Insights on a representative page. Note LCP, INP, CLS. · Identify the biggest contributor to your slow metric (image size, render-blocking JS, font loading, server TTFB). · Apply the specific fix from the action above. · Re-test in PageSpeed and check GSC → Core Web Vitals after 28 days for real-user data. · Pro tip: Lab data is a debugging tool. Field data (GSC, CrUX) is what Google ranks on. Optimize for field. - Avoid: Optimizing for lab scores (PageSpeed) instead of field data (CrUX, GSC) · Lazy-loading the LCP image (defeats the optimization) · Using a polyfill for AVIF instead of a native <picture> fallback · Skipping the fix because "we're already fast" — measure, don't assume - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 127. Ensure a consistent quality bar across ALL pages — Google scores site-wide quality/NSR; prune the worst 10% - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 128. Remove expired/outdated pages (old events, discontinued products) or 301/redirect them - How: Open your site's root config (or CMS panel) for this surface — sitemap, robots.txt, .htaccess, or nginx config. · Apply the change as specified in the action above. · Test it: curl -I https://yoursite.com/... for the response code, or use GSC URL Inspection to verify Google can fetch the result. · Submit changes in GSC → Sitemaps or Coverage for re-crawl. - Avoid: Forgetting to test with curl or GSC URL Inspection · Blocking Googlebot from the path in robots.txt while also linking to it from the sitemap (conflicting signals) · Using a build-time timestamp instead of the real last-content-change date - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 129. Add a clear next action (CTA, related links) so the page satisfies the task fully - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 130. Avoid keyword-stuffed, low-info "SEO filler" sections; every section must add unique value - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 131. Write for topical completeness, not word count — but don't under-serve (thin content demotes) - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 132. Add a "key takeaways" / summary box for long guides (snippet + skimmer friendly) - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 133. Ensure the page's main content is substantially larger than its boilerplate (nav/footer/ads) - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. ## H · Topical authority and semantics _14 actions, #134–147_ Ranking for one query is luck. Ranking for a field is structure: clusters, hubs, entity coverage, and internal links that make the relationships explicit. - [ ] 134. Pick a defined core niche and keep the site focused (leak: siteFocusScore / siteRadius reward focus) - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 135. Map the full topic space (keyword/entity map) and build a page for each meaningful subtopic - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 136. Interlink the cluster densely so the pillar accumulates internal PageRank - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 137. Run content-gap analysis (Ahrefs/SEMrush) vs the top-3 competitors; fill missing subtopics - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 138. Include semantically related entities/terms (from TF-IDF/NLP tools like Surfer/Clearscope) naturally - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 139. Cover a topic to completion before expanding into adjacent topics (avoid diluting site focus) - [ ] 140. Don't publish off-topic content on the main domain; use a separate site if truly unrelated - _Applies to the 2 actions above._ - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 141. Build supporting glossary/definition pages for the niche's core entities - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 142. Target question clusters (who/what/why/how) around each pillar for snippet + PAA coverage - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 143. Match content to intent stage (awareness→decision) and interlink across the funnel - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 144. Establish the site as the canonical source for a specific query set before chasing broad head terms - How: Open your site's root config (or CMS panel) for this surface — sitemap, robots.txt, .htaccess, or nginx config. · Apply the change as specified in the action above. · Test it: curl -I https://yoursite.com/... for the response code, or use GSC URL Inspection to verify Google can fetch the result. · Submit changes in GSC → Sitemaps or Coverage for re-crawl. - Avoid: Forgetting to test with curl or GSC URL Inspection · Blocking Googlebot from the path in robots.txt while also linking to it from the sitemap (conflicting signals) · Using a build-time timestamp instead of the real last-content-change date - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 145. Refresh and expand the pillar as the topic evolves; keep it the most complete resource - [ ] 146. Use consistent terminology/entity names across the site so Google models the topic cleanly - _Applies to the 2 actions above._ - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 147. Add internal "hub" pages that list and link all cluster content for a subtopic - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. ## I · Structured data and schema _25 actions, #148–172_ Machine-readable statements about what a page contains. It does not lift rankings directly; it decides whether you appear as a rich result, and increasingly whether an AI assistant can cite you at all. - [ ] 148. Add Organization schema on the homepage: name, url, logo, sameAs, contactPoint - [ ] 149. Add WebSite schema with potentialAction SearchAction (sitelinks searchbox) - [ ] 150. Add Article/BlogPosting schema: headline, author (Person), datePublished, dateModified, image - [ ] 151. Add BreadcrumbList schema matching the visible breadcrumb - [ ] 152. Add Person schema for authors with sameAs (LinkedIn, X, Wikipedia, ORCID) - [ ] 153. Add FAQPage schema only where the Q&A is visible on-page (Google penalizes hidden FAQ markup) - [ ] 154. Add HowTo schema for step-by-step content with images per step - _Applies to the 7 actions above._ - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 155. Add Product + Offer: price, priceCurrency, availability, priceValidUntil, itemCondition - How: Audit your URL structure: separate product, category, and filter URLs cleanly. · For products: unique title, unique description, Product + Offer schema, multiple high-res images, real reviews. · For categories: unique intro content (not just a product grid), curated links, faceted nav canonicalization. · Set up Product schema across your entire catalog and submit a Google Merchant Center feed. - Avoid: Letting faceted navigation create thousands of indexable URLs (tanks crawl budget) · Using the manufacturer's product description (duplicate content) · No Product schema on product pages · 404ing out-of-stock products instead of keeping them with alternatives - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 156. Add AggregateRating + Review only for genuine, on-page reviews (no self-serving fake ratings) - How: Sign in to Google Business Profile (or claim it). · Fill out every field. Pick the most specific primary category. Add relevant secondary categories. · Add photos weekly. Post GBP updates weekly. Respond to every review within 24-48 hours. · Build citations on the top 10 directories. - Avoid: Stuffing the business name with keywords · Buying reviews (Google detects IP/timing patterns) · Inconsistent NAP across directories · Ignoring review responses (especially negative ones) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 157. Add VideoObject: name, description, thumbnailUrl, uploadDate, duration, contentUrl - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 158. Add LocalBusiness (or subtype): NAP, geo, openingHoursSpecification, priceRange - How: Sign in to Google Business Profile (or claim it). · Fill out every field. Pick the most specific primary category. Add relevant secondary categories. · Add photos weekly. Post GBP updates weekly. Respond to every review within 24-48 hours. · Build citations on the top 10 directories. - Avoid: Stuffing the business name with keywords · Buying reviews (Google detects IP/timing patterns) · Inconsistent NAP across directories · Ignoring review responses (especially negative ones) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 159. Add Recipe, Event, JobPosting, Course, SoftwareApplication schema where the content type matches - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 160. Add ImageObject with license/acquireLicensePage for licensable-images eligibility - How: Run PageSpeed Insights on a representative page. Note LCP, INP, CLS. · Identify the biggest contributor to your slow metric (image size, render-blocking JS, font loading, server TTFB). · Apply the specific fix from the action above. · Re-test in PageSpeed and check GSC → Core Web Vitals after 28 days for real-user data. · Pro tip: Lab data is a debugging tool. Field data (GSC, CrUX) is what Google ranks on. Optimize for field. - Avoid: Optimizing for lab scores (PageSpeed) instead of field data (CrUX, GSC) · Lazy-loading the LCP image (defeats the optimization) · Using a polyfill for AVIF instead of a native <picture> fallback · Skipping the fix because "we're already fast" — measure, don't assume - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 161. Add sameAs links everywhere to connect the entity to Wikidata/Wikipedia/Crunchbase/social - [ ] 162. Use a single connected @graph with @id references so entities link (Org↔Author↔Article) - _Applies to the 2 actions above._ - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 163. Add speakable schema for voice-eligible news/how-to content - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 164. Add MerchantReturnPolicy + shippingDetails for product/merchant listings - How: Audit your URL structure: separate product, category, and filter URLs cleanly. · For products: unique title, unique description, Product + Offer schema, multiple high-res images, real reviews. · For categories: unique intro content (not just a product grid), curated links, faceted nav canonicalization. · Set up Product schema across your entire catalog and submit a Google Merchant Center feed. - Avoid: Letting faceted navigation create thousands of indexable URLs (tanks crawl budget) · Using the manufacturer's product description (duplicate content) · No Product schema on product pages · 404ing out-of-stock products instead of keeping them with alternatives - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 165. Add QAPage schema for genuine user Q&A pages (not FAQPage) - [ ] 166. Validate every template in Google Rich Results Test + Schema.org validator; fix all errors/warnings - [ ] 167. Keep schema values consistent with visible on-page content (mismatch = ineligible/penalty) - [ ] 168. Monitor GSC → Enhancements for schema errors and impressions per rich-result type - [ ] 169. Prefer JSON-LD in <head>; keep it server-rendered so Googlebot reads it without JS - _Applies to the 5 actions above._ - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 170. Add dateModified that updates only on real content changes (feeds freshness) - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 171. Add WebPage/CollectionPage typing + primaryImageOfPage on templates - How: Run PageSpeed Insights on a representative page. Note LCP, INP, CLS. · Identify the biggest contributor to your slow metric (image size, render-blocking JS, font loading, server TTFB). · Apply the specific fix from the action above. · Re-test in PageSpeed and check GSC → Core Web Vitals after 28 days for real-user data. · Pro tip: Lab data is a debugging tool. Field data (GSC, CrUX) is what Google ranks on. Optimize for field. - Avoid: Optimizing for lab scores (PageSpeed) instead of field data (CrUX, GSC) · Lazy-loading the LCP image (defeats the optimization) · Using a polyfill for AVIF instead of a native <picture> fallback · Skipping the fix because "we're already fast" — measure, don't assume - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 172. Remove deprecated/spammy markup (fake ratings, hidden HowTo) that risks manual action - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. ## J · Freshness _12 actions, #173–184_ Some queries reward recency and most do not. These actions distinguish the two, and stop the common mistake of bumping dates on pages nobody asked to be updated. - [ ] 173. Show a visible Published and Last updated date on articles - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 174. Keep datePublished/dateModified in schema accurate and in sync with visible dates - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 175. Update <lastmod> in the sitemap on every meaningful edit - How: Open your site's root config (or CMS panel) for this surface — sitemap, robots.txt, .htaccess, or nginx config. · Apply the change as specified in the action above. · Test it: curl -I https://yoursite.com/... for the response code, or use GSC URL Inspection to verify Google can fetch the result. · Submit changes in GSC → Sitemaps or Coverage for re-crawl. - Avoid: Forgetting to test with curl or GSC URL Inspection · Blocking Googlebot from the path in robots.txt while also linking to it from the sitemap (conflicting signals) · Using a build-time timestamp instead of the real last-content-change date - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 176. When updating, change real body content (stats, sections, examples) — not just the date (fake freshness demotes) - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 177. Refresh statistics, prices, and "in [year]" references on key pages each quarter - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 178. Replace outdated citations/sources with current ones; remove dead references - How: Sign in to Google Business Profile (or claim it). · Fill out every field. Pick the most specific primary category. Add relevant secondary categories. · Add photos weekly. Post GBP updates weekly. Respond to every review within 24-48 hours. · Build citations on the top 10 directories. - Avoid: Stuffing the business name with keywords · Buying reviews (Google detects IP/timing patterns) · Inconsistent NAP across directories · Ignoring review responses (especially negative ones) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 179. Add new sections/subtopics to top pages as the topic evolves instead of leaving them static - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 180. Fix/replace dead outbound links (broken external links hurt quality signals) - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 181. Prioritize freshness for QDF/trending queries (news, "best 2026", releases); update ahead of the peak - [ ] 182. Set a re-optimization cadence: audit top-20 pages by traffic for decay every 90 days - _Applies to the 2 actions above._ - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 183. Update the byline/author info and re-verify facts on refreshed evergreen content - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 184. Re-promote significantly updated content (internal links from new posts, resend/newsletter) - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. ## K · Clicks, CTR and the results page _16 actions, #185–200_ Two pages at the same position do not get the same traffic. What your listing looks like — title, description, breadcrumb, favicon, rich result — decides the difference. - [ ] 185. Pull GSC queries with high impressions + low CTR; rewrite those titles/descriptions first - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 186. A/B test titles (numbers, brackets, year, "how to") and keep the higher-CTR variant - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 187. Match the SERP promise to on-page content so users don't bounce back (kills goodClicks, feeds badClicks) - [ ] 188. Strengthen the first screen so the searcher's need is visibly met within 5 seconds (dwell / lastLongestClicks) - _Applies to the 2 actions above._ - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 189. Format for Featured Snippets: 40–60 word definition blocks, ordered lists for "how to", tables for comparisons - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 190. Target People Also Ask by adding the exact question as a heading + concise answer - How: Open one of your most important pages. · Apply the change from the action above. · Test it renders correctly. Check the SERP preview using Google's results or a SERP simulator. · Track in GSC: did CTR change? Position? Wait 2-4 weeks for stable signal. - Avoid: Stuffing keywords into the title or H1 to "rank higher" — Google rewrites these · Using the same meta description across multiple pages · Having multiple H1s on a page · Writing titles >60 chars and letting them truncate in SERP - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 191. Earn rich results (FAQ/Review/Product/Video) to enlarge SERP footprint and CTR - How: Sign in to Google Business Profile (or claim it). · Fill out every field. Pick the most specific primary category. Add relevant secondary categories. · Add photos weekly. Post GBP updates weekly. Respond to every review within 24-48 hours. · Build citations on the top 10 directories. - Avoid: Stuffing the business name with keywords · Buying reviews (Google detects IP/timing patterns) · Inconsistent NAP across directories · Ignoring review responses (especially negative ones) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 192. Add a compelling meta description CTA aligned to intent (buy/learn/compare) - How: Open one of your most important pages. · Apply the change from the action above. · Test it renders correctly. Check the SERP preview using Google's results or a SERP simulator. · Track in GSC: did CTR change? Position? Wait 2-4 weeks for stable signal. - Avoid: Stuffing keywords into the title or H1 to "rank higher" — Google rewrites these · Using the same meta description across multiple pages · Having multiple H1s on a page · Writing titles >60 chars and letting them truncate in SERP - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 193. Get sitelinks by strong internal linking + clear section structure - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 194. Win the "freshness" date shown in SERP by keeping dateModified honest and recent - [ ] 195. Reduce pogo-sticking: fast load + immediate answer + clear next step - [ ] 196. Build branded-search demand (PR, social, ads, offline) — branded clicks are a strong Navboost signal - _Applies to the 3 actions above._ - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 197. Optimize for the whole SERP: if it's video/image-heavy, produce that media type - How: Run PageSpeed Insights on a representative page. Note LCP, INP, CLS. · Identify the biggest contributor to your slow metric (image size, render-blocking JS, font loading, server TTFB). · Apply the specific fix from the action above. · Re-test in PageSpeed and check GSC → Core Web Vitals after 28 days for real-user data. · Pro tip: Lab data is a debugging tool. Field data (GSC, CrUX) is what Google ranks on. Optimize for field. - Avoid: Optimizing for lab scores (PageSpeed) instead of field data (CrUX, GSC) · Lazy-loading the LCP image (defeats the optimization) · Using a polyfill for AVIF instead of a native <picture> fallback · Skipping the fix because "we're already fast" — measure, don't assume - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 198. Add favicon + clean breadcrumb URL display for a more clickable listing - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 199. Monitor CTR by position (GSC) and re-test underperformers vs their position's expected CTR - How: Set up Google Search Console (free, 5 minutes). · Add Bing Webmaster Tools (free, 5 minutes). · Set up alerts: traffic drops, manual actions, CWV regressions, indexing errors. · Build a weekly review: 30 minutes, same day, same dashboard. Look at clicks, impressions, CTR, position by query. - Avoid: Setting up tracking and never looking at it · Not verifying site ownership in GSC · Too many tools without a clear question to answer · Ignoring manual actions in GSC (penalty trigger) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 200. Keep meta titles honest to avoid Google rewriting them (rewrites often lower CTR) - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. ## L · Backlinks and digital PR _26 actions, #201–226_ Still the strongest external signal, and the easiest to get catastrophically wrong. These actions cover earning links, reclaiming unlinked mentions, and building assets other people want to cite. - [ ] 201. Run one original data study/survey per quarter (500+ respondents via Pollfish/SurveyMonkey Audience); publish as "[Industry] Report [year]" with charts - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 202. Build a "[Topic] Statistics [year]" page (50+ cited stats) to farm passive citation links - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 203. Build a media/journalist list in Muck Rack or Prowly; pitch each study to 30+ niche reporters - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 204. Answer 3 journalist queries/day on Qwoted, Featured.com, SourceBottle, Help a B2B Writer (HARO retired Dec 2024) - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 205. Ship 1 free interactive tool/calculator for your niche (e.g. finance→loan calc, SaaS→ROI calc, fitness→TDEE calc) with an "Embed this" snippet that hard-codes a backlink - [ ] 206. Publish 1 niche-specific downloadable template (e.g. content→editorial-calendar Sheet, finance→budget template, agency→SOW template), gate behind email, share in the niche's top-3 subreddits + relevant LinkedIn groups - [ ] 207. Create a linkbait "ultimate guide" pillar (original diagrams, 3,000+ words) as an outreach asset - [ ] 208. Resource-page link building: intitle:resources "[topic]", inurl:links.html "[topic]"; pitch your asset - [ ] 209. Guest-post prospecting: "[niche]" "write for us", "[niche]" inurl:guest-post, "[niche]" "contribute" - [ ] 210. Broken-link building: in Ahrefs, export a competitor's 404 backlinks; offer your live equivalent to linkers - [ ] 211. Link Intersect (Ahrefs): find domains linking to ≥2 competitors but not you; pitch them - [ ] 212. Reclaim unlinked brand mentions: Google Alerts + Ahrefs Content Explorer → request the link - [ ] 213. Guest on 2 niche podcasts/month for bio-link + branded mentions - _Applies to the 9 actions above._ - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 214. Get added to existing "best [product/service] [year]" listicles via outreach to the author - How: Identify what makes you credible: years of experience, certifications, published work, real client results. · Make it visible: author bio on every article, About page with real names, contact info. · Prove it: cite primary sources, link to your published work, mention specific projects. · Get external validation: media mentions, podcast appearances, bylines in industry publications. - Avoid: Generic "admin" byline without a real person attached · Fake credentials or exaggerated experience · No contact information (real address, real phone) · Missing or generic About page - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 215. Launch products/tools on Product Hunt (and BetaList) for a high-authority link burst - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 216. Publish free original tools/datasets on GitHub with a link back to the canonical page - How: Open your site's root config (or CMS panel) for this surface — sitemap, robots.txt, .htaccess, or nginx config. · Apply the change as specified in the action above. · Test it: curl -I https://yoursite.com/... for the response code, or use GSC URL Inspection to verify Google can fetch the result. · Submit changes in GSC → Sitemaps or Coverage for re-crawl. - Avoid: Forgetting to test with curl or GSC URL Inspection · Blocking Googlebot from the path in robots.txt while also linking to it from the sitemap (conflicting signals) · Using a build-time timestamp instead of the real last-content-change date - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 217. Sponsor/speak at niche events/podcasts/newsletters that include a do-follow profile link - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 218. Turn the data study into an infographic; pitch with an embed code to niche blogs - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 219. Pursue links from topically relevant pages (co-relevant beats high-DR-but-off-topic) — leak weights source relevance - [ ] 220. Prioritize editorially-placed, in-content links over footer/sidebar/author-bio links - [ ] 221. Diversify referring domains (aim for new unique domains monthly, not more links from the same few) - [ ] 222. Avoid link schemes: paid do-follow links, PBNs, mass directory/blog-comment spam, link exchanges at scale - [ ] 223. Set rel="sponsored" on any paid/affiliate links; rel="ugc" on user-generated - _Applies to the 5 actions above._ - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 224. Vet targets: skip domains with spammy outbound profiles, thin content, or unrelated topics - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 225. Build relationships (comment, share, quote) with niche creators before pitching links - [ ] 226. Convert internal mentions of brands/tools into 2-way link relationships where appropriate - _Applies to the 2 actions above._ - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. ## M · Anchor-text hygiene _9 actions, #227–235_ The words pointing at a page describe it to Google. Over-optimise and you trip a spam filter; ignore it and you leave the description to chance. - [ ] 227. Keep branded + naked-URL + "here/website" anchors ≥50% of the inbound profile (natural distribution) - [ ] 228. Keep exact-match commercial anchors <10% of profile to avoid AnchorSpamPenalizer / AnchorPhraseSpam demotion - [ ] 229. Favor partial-match and topic-descriptive anchors over exact-match money terms - [ ] 230. Audit anchor distribution quarterly (Ahrefs → Anchors); fix spikes of identical commercial anchors - [ ] 231. Vary anchors across a link campaign; don't request the same anchor from every site - [ ] 232. Watch for negative-SEO anchor spam (sudden exact-match spikes) and disavow if toxic - [ ] 233. Ensure internal anchors to a target are keyword-consistent but not identical every time - [ ] 234. Avoid site-wide (footer/template) links with commercial anchors (treated as one weighted, spam-prone link) - [ ] 235. Match anchor text to the destination page's actual topic/intent - _Applies to the 9 actions above._ - How: Open one of your most important pages. · Apply the change from the action above. · Test it renders correctly. Check the SERP preview using Google's results or a SERP simulator. · Track in GSC: did CTR change? Position? Wait 2-4 weeks for stable signal. - Avoid: Stuffing keywords into the title or H1 to "rank higher" — Google rewrites these · Using the same meta description across multiple pages · Having multiple H1s on a page · Writing titles >60 chars and letting them truncate in SERP - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. ## N · Entities, Knowledge Graph and E-E-A-T _21 actions, #236–256_ Google resolves your brand and your authors to entities it already knows. These actions make that resolution unambiguous, and attach the experience and credentials that back the claims on the page. - [ ] 236. Create a Wikidata item (wikidata.org) for the brand + founder/key authors to seed the Knowledge Graph - How: Identify what makes you credible: years of experience, certifications, published work, real client results. · Make it visible: author bio on every article, About page with real names, contact info. · Prove it: cite primary sources, link to your published work, mention specific projects. · Get external validation: media mentions, podcast appearances, bylines in industry publications. - Avoid: Generic "admin" byline without a real person attached · Fake credentials or exaggerated experience · No contact information (real address, real phone) · Missing or generic About page - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 237. Create a Wikipedia page ONLY if you meet notability (3+ independent, reliable secondary sources); otherwise don't force it - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 238. Where relevant and factual, add well-sourced citations to existing Wikipedia articles (traffic + entity signal) - How: Identify what makes you credible: years of experience, certifications, published work, real client results. · Make it visible: author bio on every article, About page with real names, contact info. · Prove it: cite primary sources, link to your published work, mention specific projects. · Get external validation: media mentions, podcast appearances, bylines in industry publications. - Avoid: Generic "admin" byline without a real person attached · Fake credentials or exaggerated experience · No contact information (real address, real phone) · Missing or generic About page - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 239. Complete a Crunchbase profile (company) + LinkedIn Company Page with consistent name/description - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 240. Wire sameAs in Organization/Person schema to Wikidata, Wikipedia, Crunchbase, LinkedIn, X, YouTube - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 241. Build a detailed author bio (credentials, experience, links) at the top/bottom of every article - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 242. Create a dedicated author page per writer with photo, bio, expertise, social + Person schema - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 243. Keep author bylines consistent site-wide; one canonical name/spelling per author - How: Open your site's root config (or CMS panel) for this surface — sitemap, robots.txt, .htaccess, or nginx config. · Apply the change as specified in the action above. · Test it: curl -I https://yoursite.com/... for the response code, or use GSC URL Inspection to verify Google can fetch the result. · Submit changes in GSC → Sitemaps or Coverage for re-crawl. - Avoid: Forgetting to test with curl or GSC URL Inspection · Blocking Googlebot from the path in robots.txt while also linking to it from the sitemap (conflicting signals) · Using a build-time timestamp instead of the real last-content-change date - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 244. Get authors quoted/published on other authoritative sites to build their entity (leak: author/Webref mentions) - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 245. Add author profiles on Muck Rack (journalists), ORCID (academics), Google Scholar where applicable - How: Identify what makes you credible: years of experience, certifications, published work, real client results. · Make it visible: author bio on every article, About page with real names, contact info. · Prove it: cite primary sources, link to your published work, mention specific projects. · Get external validation: media mentions, podcast appearances, bylines in industry publications. - Avoid: Generic "admin" byline without a real person attached · Fake credentials or exaggerated experience · No contact information (real address, real phone) · Missing or generic About page - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 246. Publish a real About page (team, history, mission) and a Contact page with physical address + phone - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 247. Display trust signals: certifications, awards, editorial policy, review process, privacy/terms pages - How: Sign in to Google Business Profile (or claim it). · Fill out every field. Pick the most specific primary category. Add relevant secondary categories. · Add photos weekly. Post GBP updates weekly. Respond to every review within 24-48 hours. · Build citations on the top 10 directories. - Avoid: Stuffing the business name with keywords · Buying reviews (Google detects IP/timing patterns) · Inconsistent NAP across directories · Ignoring review responses (especially negative ones) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 248. For YMYL (health/finance/legal), show expert authors, medical/professional review lines, and cited sources - [ ] 249. Build consistent brand entity mentions across the web (PR, interviews, directories) — co-citation matters - [ ] 250. Encourage and track branded search volume; a recognized entity gets brand-query preference - [ ] 251. Keep NAP + brand name/logo consistent everywhere to reinforce one entity - [ ] 252. Aim for a Google Knowledge Panel by combining Wikidata + consistent sameAs + authoritative mentions - _Applies to the 5 actions above._ - How: Identify what makes you credible: years of experience, certifications, published work, real client results. · Make it visible: author bio on every article, About page with real names, contact info. · Prove it: cite primary sources, link to your published work, mention specific projects. · Get external validation: media mentions, podcast appearances, bylines in industry publications. - Avoid: Generic "admin" byline without a real person attached · Fake credentials or exaggerated experience · No contact information (real address, real phone) · Missing or generic About page - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 253. Add founder, foundingDate, numberOfEmployees, award to Organization schema where true - [ ] 254. Link the brand entity across owned properties (blog, docs, help, social) with consistent schema @id - _Applies to the 2 actions above._ - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 255. Get real customer reviews on third-party platforms (Trustpilot/G2/Google) to reinforce trust - How: Sign in to Google Business Profile (or claim it). · Fill out every field. Pick the most specific primary category. Add relevant secondary categories. · Add photos weekly. Post GBP updates weekly. Respond to every review within 24-48 hours. · Build citations on the top 10 directories. - Avoid: Stuffing the business name with keywords · Buying reviews (Google detects IP/timing patterns) · Inconsistent NAP across directories · Ignoring review responses (especially negative ones) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 256. Publish thought-leadership under named experts, not a generic "admin"/"team" byline - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. ## O · Image SEO _18 actions, #257–274_ Images carry weight in two directions: they are the largest cause of slow pages, and they are a search surface of their own. - [ ] 257. Name image files descriptively with keywords: blue-running-shoe-side.avif, not IMG_2931.jpg - [ ] 258. Write specific alt text describing the image + context (not keyword-stuffed): "Chart: US EV sales 2020–2026" - [ ] 259. Add a visible caption on key images (captions get read more than surrounding text) - [ ] 260. Serve high-resolution, sharp images; avoid blur/artifacts (leak: DocumentPageImageQualityScores defects) - [ ] 261. Use unique/original images where possible; heavy stock reuse is a weaker/duplicative signal - _Applies to the 5 actions above._ - How: Run PageSpeed Insights on a representative page. Note LCP, INP, CLS. · Identify the biggest contributor to your slow metric (image size, render-blocking JS, font loading, server TTFB). · Apply the specific fix from the action above. · Re-test in PageSpeed and check GSC → Core Web Vitals after 28 days for real-user data. · Pro tip: Lab data is a debugging tool. Field data (GSC, CrUX) is what Google ranks on. Optimize for field. - Avoid: Optimizing for lab scores (PageSpeed) instead of field data (CrUX, GSC) · Lazy-loading the LCP image (defeats the optimization) · Using a polyfill for AVIF instead of a native <picture> fallback · Skipping the fix because "we're already fast" — measure, don't assume - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 262. Provide an image sitemap (or <image:image> in the sitemap) with each page's key images - How: Open your site's root config (or CMS panel) for this surface — sitemap, robots.txt, .htaccess, or nginx config. · Apply the change as specified in the action above. · Test it: curl -I https://yoursite.com/... for the response code, or use GSC URL Inspection to verify Google can fetch the result. · Submit changes in GSC → Sitemaps or Coverage for re-crawl. - Avoid: Forgetting to test with curl or GSC URL Inspection · Blocking Googlebot from the path in robots.txt while also linking to it from the sitemap (conflicting signals) · Using a build-time timestamp instead of the real last-content-change date - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 263. Keep the primary/most-relevant image near the top of the page and in the main content - [ ] 264. Add IPTC/ImageObject license + creator metadata for Licensable-image badges - [ ] 265. Set og:image (1200×630) + twitter:image for social/SERP previews - [ ] 266. Use srcset/sizes responsive images (also a speed win) - [ ] 267. Compress to next-gen formats (AVIF/WebP) — see Section D - [ ] 268. Surround images with topically relevant text; Google uses page context to rank images - [ ] 269. Avoid text-in-image for important content; keep it as real HTML text too - _Applies to the 7 actions above._ - How: Run PageSpeed Insights on a representative page. Note LCP, INP, CLS. · Identify the biggest contributor to your slow metric (image size, render-blocking JS, font loading, server TTFB). · Apply the specific fix from the action above. · Re-test in PageSpeed and check GSC → Core Web Vitals after 28 days for real-user data. · Pro tip: Lab data is a debugging tool. Field data (GSC, CrUX) is what Google ranks on. Optimize for field. - Avoid: Optimizing for lab scores (PageSpeed) instead of field data (CrUX, GSC) · Lazy-loading the LCP image (defeats the optimization) · Using a polyfill for AVIF instead of a native <picture> fallback · Skipping the fix because "we're already fast" — measure, don't assume - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 270. Add descriptive title/context for infographics + an HTML transcript of their data - How: Record your video (or commission it). Minimum 720p, ideally 1080p. · Get a full transcript (auto-generated is fine, then edit). · Upload to YouTube with keyword-rich title, detailed description (with timestamps), relevant tags. · Embed on your own site with VideoObject schema and a visible transcript below. - Avoid: No transcript (Google can't rank what it can't read) · Boring first 30 seconds (most viewers drop off here) · Auto-generated YouTube thumbnail (low contrast, low CTR) · Uploading to YouTube but not embedding on your own site - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 271. Ensure images are crawlable (<img src>, not CSS background) for important visuals - How: Run PageSpeed Insights on a representative page. Note LCP, INP, CLS. · Identify the biggest contributor to your slow metric (image size, render-blocking JS, font loading, server TTFB). · Apply the specific fix from the action above. · Re-test in PageSpeed and check GSC → Core Web Vitals after 28 days for real-user data. · Pro tip: Lab data is a debugging tool. Field data (GSC, CrUX) is what Google ranks on. Optimize for field. - Avoid: Optimizing for lab scores (PageSpeed) instead of field data (CrUX, GSC) · Lazy-loading the LCP image (defeats the optimization) · Using a polyfill for AVIF instead of a native <picture> fallback · Skipping the fix because "we're already fast" — measure, don't assume - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 272. Provide an ImageObject in Product/Article schema with a high-res contentUrl - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 273. Keep image URLs stable; don't rehash filenames on every deploy (preserves image-search equity) - [ ] 274. Optimize thumbnail crops so the subject is centered/clear (feeds image click signals) - _Applies to the 2 actions above._ - How: Run PageSpeed Insights on a representative page. Note LCP, INP, CLS. · Identify the biggest contributor to your slow metric (image size, render-blocking JS, font loading, server TTFB). · Apply the specific fix from the action above. · Re-test in PageSpeed and check GSC → Core Web Vitals after 28 days for real-user data. · Pro tip: Lab data is a debugging tool. Field data (GSC, CrUX) is what Google ranks on. Optimize for field. - Avoid: Optimizing for lab scores (PageSpeed) instead of field data (CrUX, GSC) · Lazy-loading the LCP image (defeats the optimization) · Using a polyfill for AVIF instead of a native <picture> fallback · Skipping the fix because "we're already fast" — measure, don't assume - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. ## P · Video SEO _14 actions, #275–288_ Video ranks in its own vertical, appears in web results, and is read by AI assistants through transcripts. Most of the opportunity is in the metadata nobody fills in. - [ ] 275. Host key videos on your domain AND YouTube; embed the self-hosted/YT player on the relevant page - How: Record your video (or commission it). Minimum 720p, ideally 1080p. · Get a full transcript (auto-generated is fine, then edit). · Upload to YouTube with keyword-rich title, detailed description (with timestamps), relevant tags. · Embed on your own site with VideoObject schema and a visible transcript below. - Avoid: No transcript (Google can't rank what it can't read) · Boring first 30 seconds (most viewers drop off here) · Auto-generated YouTube thumbnail (low contrast, low CTR) · Uploading to YouTube but not embedding on your own site - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 276. Add VideoObject schema (name, description, thumbnailUrl, uploadDate, duration, contentUrl/embedUrl) - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 277. Provide a custom, high-contrast, subject-clear thumbnail (leak: ThumbnailQualityScore, moving thumbnails) - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 278. Upload a full transcript on-page and closed captions (.vtt) — indexable + accessibility - [ ] 279. Add chapter markers (SeekToAction / YouTube timestamps) for Key Moments eligibility - _Applies to the 2 actions above._ - How: Record your video (or commission it). Minimum 720p, ideally 1080p. · Get a full transcript (auto-generated is fine, then edit). · Upload to YouTube with keyword-rich title, detailed description (with timestamps), relevant tags. · Embed on your own site with VideoObject schema and a visible transcript below. - Avoid: No transcript (Google can't rank what it can't read) · Boring first 30 seconds (most viewers drop off here) · Auto-generated YouTube thumbnail (low contrast, low CTR) · Uploading to YouTube but not embedding on your own site - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 280. Write a keyword-rich video title + a detailed description with the target query - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 281. Submit a video sitemap (or <video:video> extension) with thumbnail + content location - How: Open your site's root config (or CMS panel) for this surface — sitemap, robots.txt, .htaccess, or nginx config. · Apply the change as specified in the action above. · Test it: curl -I https://yoursite.com/... for the response code, or use GSC URL Inspection to verify Google can fetch the result. · Submit changes in GSC → Sitemaps or Coverage for re-crawl. - Avoid: Forgetting to test with curl or GSC URL Inspection · Blocking Googlebot from the path in robots.txt while also linking to it from the sitemap (conflicting signals) · Using a build-time timestamp instead of the real last-content-change date - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 282. Place the video near the top of a page whose main topic IS that video (video-focused page) - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 283. Keep the video's surrounding page text relevant and unique (context ranks the video) - How: Record your video (or commission it). Minimum 720p, ideally 1080p. · Get a full transcript (auto-generated is fine, then edit). · Upload to YouTube with keyword-rich title, detailed description (with timestamps), relevant tags. · Embed on your own site with VideoObject schema and a visible transcript below. - Avoid: No transcript (Google can't rank what it can't read) · Boring first 30 seconds (most viewers drop off here) · Auto-generated YouTube thumbnail (low contrast, low CTR) · Uploading to YouTube but not embedding on your own site - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 284. Ensure the thumbnail image is crawlable and matches the schema thumbnailUrl - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 285. Add engaging first 5–10 seconds to improve watch-time/engagement signals - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 286. Localize captions/transcripts for target languages - How: Sign in to Google Business Profile (or claim it). · Fill out every field. Pick the most specific primary category. Add relevant secondary categories. · Add photos weekly. Post GBP updates weekly. Respond to every review within 24-48 hours. · Build citations on the top 10 directories. - Avoid: Stuffing the business name with keywords · Buying reviews (Google detects IP/timing patterns) · Inconsistent NAP across directories · Ignoring review responses (especially negative ones) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 287. Avoid autoplay-with-sound; it hurts engagement and mobile UX - How: Open your site on a real phone on real 4G. Note what feels slow or broken. · Open Chrome DevTools → Device Mode → Responsive → 360px width. Look for horizontal scroll, tiny text, close tap targets. · Check GSC → Experience → Mobile Usability. · Fix: viewport meta, responsive design, 48×48px tap targets, ≥16px body text. - Avoid: Testing only on desktop · Hidden text behind "read more" accordions (Google weighs less) · Full-screen popups covering content on load · Tap targets <48px or <8px spacing - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 288. Optimize YouTube metadata (tags, playlist, end screens) since YT results appear in Google - How: Record your video (or commission it). Minimum 720p, ideally 1080p. · Get a full transcript (auto-generated is fine, then edit). · Upload to YouTube with keyword-rich title, detailed description (with timestamps), relevant tags. · Embed on your own site with VideoObject schema and a visible transcript below. - Avoid: No transcript (Google can't rank what it can't read) · Boring first 30 seconds (most viewers drop off here) · Auto-generated YouTube thumbnail (low contrast, low CTR) · Uploading to YouTube but not embedding on your own site - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. ## Q · Local SEO _20 actions, #289–308_ For a business with a physical location or a service area, the map is the result page. These actions cover the profile, the citations, the reviews and the on-site signals that decide who appears on it. - [ ] 289. Create and 100%-complete a Google Business Profile (every field, hours, attributes) - [ ] 290. Choose the most specific primary GBP category + relevant secondary categories - [ ] 291. Keep NAP (name, address, phone) byte-identical across GBP, site, and all citations - _Applies to the 3 actions above._ - How: Sign in to Google Business Profile (or claim it). · Fill out every field. Pick the most specific primary category. Add relevant secondary categories. · Add photos weekly. Post GBP updates weekly. Respond to every review within 24-48 hours. · Build citations on the top 10 directories. - Avoid: Stuffing the business name with keywords · Buying reviews (Google detects IP/timing patterns) · Inconsistent NAP across directories · Ignoring review responses (especially negative ones) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 292. Add LocalBusiness schema with geo coordinates, openingHoursSpecification, sameAs to GBP - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 293. Post GBP updates weekly (offers, news, events) and upload fresh geo-tagged photos - How: Sign in to Google Business Profile (or claim it). · Fill out every field. Pick the most specific primary category. Add relevant secondary categories. · Add photos weekly. Post GBP updates weekly. Respond to every review within 24-48 hours. · Build citations on the top 10 directories. - Avoid: Stuffing the business name with keywords · Buying reviews (Google detects IP/timing patterns) · Inconsistent NAP across directories · Ignoring review responses (especially negative ones) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 294. Actively collect Google reviews (post-purchase ask) and respond to every review within days - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 295. Seed core-aggregator citations that feed hundreds downstream: Data Axle, Localeze, Foursquare - How: Sign in to Google Business Profile (or claim it). · Fill out every field. Pick the most specific primary category. Add relevant secondary categories. · Add photos weekly. Post GBP updates weekly. Respond to every review within 24-48 hours. · Build citations on the top 10 directories. - Avoid: Stuffing the business name with keywords · Buying reviews (Google detects IP/timing patterns) · Inconsistent NAP across directories · Ignoring review responses (especially negative ones) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 296. Add general directories: Yelp, Bing Places, Apple Business Connect, Facebook, Nextdoor, BBB.org, YellowPages, Hotfrog, Manta - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 297. Add industry citations — SaaS: G2/Capterra/TrustRadius · Agencies: Clutch/DesignRush · Legal: Avvo/Justia/FindLaw · Medical: Healthgrades/Zocdoc/Vitals · Home: Houzz/Angi/Thumbtack · Travel: TripAdvisor/OpenTable - [ ] 298. Audit citation consistency with BrightLocal or Whitespark; fix conflicting NAP - _Applies to the 2 actions above._ - How: Sign in to Google Business Profile (or claim it). · Fill out every field. Pick the most specific primary category. Add relevant secondary categories. · Add photos weekly. Post GBP updates weekly. Respond to every review within 24-48 hours. · Build citations on the top 10 directories. - Avoid: Stuffing the business name with keywords · Buying reviews (Google detects IP/timing patterns) · Inconsistent NAP across directories · Ignoring review responses (especially negative ones) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 299. Build a unique landing page per location/service area with local content (not doorway duplicates) - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 300. Embed a Google Map + driving directions on each location page - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 301. Add city/region + service keywords to titles, H1s, and content on location pages - How: Open one of your most important pages. · Apply the change from the action above. · Test it renders correctly. Check the SERP preview using Google's results or a SERP simulator. · Track in GSC: did CTR change? Position? Wait 2-4 weeks for stable signal. - Avoid: Stuffing keywords into the title or H1 to "rank higher" — Google rewrites these · Using the same meta description across multiple pages · Having multiple H1s on a page · Writing titles >60 chars and letting them truncate in SERP - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 302. Earn local backlinks: chamber of commerce, local news, sponsorships, local blogs - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 303. Answer GBP Q&A; seed common questions with accurate answers - How: Sign in to Google Business Profile (or claim it). · Fill out every field. Pick the most specific primary category. Add relevant secondary categories. · Add photos weekly. Post GBP updates weekly. Respond to every review within 24-48 hours. · Build citations on the top 10 directories. - Avoid: Stuffing the business name with keywords · Buying reviews (Google detects IP/timing patterns) · Inconsistent NAP across directories · Ignoring review responses (especially negative ones) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 304. Keep holiday/special hours updated in GBP and schema - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 305. Get niche local reviews on relevant platforms (TripAdvisor, Healthgrades, etc.) too - How: Sign in to Google Business Profile (or claim it). · Fill out every field. Pick the most specific primary category. Add relevant secondary categories. · Add photos weekly. Post GBP updates weekly. Respond to every review within 24-48 hours. · Build citations on the top 10 directories. - Avoid: Stuffing the business name with keywords · Buying reviews (Google detects IP/timing patterns) · Inconsistent NAP across directories · Ignoring review responses (especially negative ones) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 306. Add store locator with individually indexable, schema-marked location URLs - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 307. Use consistent business description + logo across all profiles (entity reinforcement) - How: Identify what makes you credible: years of experience, certifications, published work, real client results. · Make it visible: author bio on every article, About page with real names, contact info. · Prove it: cite primary sources, link to your published work, mention specific projects. · Get external validation: media mentions, podcast appearances, bylines in industry publications. - Avoid: Generic "admin" byline without a real person attached · Fake credentials or exaggerated experience · No contact information (real address, real phone) · Missing or generic About page - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 308. Monitor GBP Insights (calls, directions, searches) and optimize weak metrics - How: Sign in to Google Business Profile (or claim it). · Fill out every field. Pick the most specific primary category. Add relevant secondary categories. · Add photos weekly. Post GBP updates weekly. Respond to every review within 24-48 hours. · Build citations on the top 10 directories. - Avoid: Stuffing the business name with keywords · Buying reviews (Google detects IP/timing patterns) · Inconsistent NAP across directories · Ignoring review responses (especially negative ones) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. ## R · E-commerce and shopping _18 actions, #309–326_ Product pages have their own failure modes: variants, out-of-stock states, thin category pages, and feeds that disagree with the site. - [ ] 309. Write unique product descriptions; never reuse the manufacturer's boilerplate (duplicate content) - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 310. Add Product schema with gtin/mpn/brand, Offer price/availability/priceValidUntil - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 311. Add real AggregateRating + Review from genuine customers (no fabricated ratings) - How: Sign in to Google Business Profile (or claim it). · Fill out every field. Pick the most specific primary category. Add relevant secondary categories. · Add photos weekly. Post GBP updates weekly. Respond to every review within 24-48 hours. · Build citations on the top 10 directories. - Avoid: Stuffing the business name with keywords · Buying reviews (Google detects IP/timing patterns) · Inconsistent NAP across directories · Ignoring review responses (especially negative ones) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 312. Add shippingDetails + MerchantReturnPolicy schema for free-listings/rich results - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 313. Control faceted navigation: noindex or robots-block filter/sort combos; keep clean canonicals - How: Open your site's root config (or CMS panel) for this surface — sitemap, robots.txt, .htaccess, or nginx config. · Apply the change as specified in the action above. · Test it: curl -I https://yoursite.com/... for the response code, or use GSC URL Inspection to verify Google can fetch the result. · Submit changes in GSC → Sitemaps or Coverage for re-crawl. - Avoid: Forgetting to test with curl or GSC URL Inspection · Blocking Googlebot from the path in robots.txt while also linking to it from the sitemap (conflicting signals) · Using a build-time timestamp instead of the real last-content-change date - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 314. Keep out-of-stock/discontinued products live with alternatives or 301 to category (don't 404 equity) - How: Audit your URL structure: separate product, category, and filter URLs cleanly. · For products: unique title, unique description, Product + Offer schema, multiple high-res images, real reviews. · For categories: unique intro content (not just a product grid), curated links, faceted nav canonicalization. · Set up Product schema across your entire catalog and submit a Google Merchant Center feed. - Avoid: Letting faceted navigation create thousands of indexable URLs (tanks crawl budget) · Using the manufacturer's product description (duplicate content) · No Product schema on product pages · 404ing out-of-stock products instead of keeping them with alternatives - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 315. Give category pages unique intro content + curated internal links (not just a product grid) - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 316. Add unique, keyword-optimized titles/H1 per product and category - How: Open one of your most important pages. · Apply the change from the action above. · Test it renders correctly. Check the SERP preview using Google's results or a SERP simulator. · Track in GSC: did CTR change? Position? Wait 2-4 weeks for stable signal. - Avoid: Stuffing keywords into the title or H1 to "rank higher" — Google rewrites these · Using the same meta description across multiple pages · Having multiple H1s on a page · Writing titles >60 chars and letting them truncate in SERP - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 317. Optimize product images (multiple angles, zoom, AVIF/WebP, descriptive alt/filename) - How: Run PageSpeed Insights on a representative page. Note LCP, INP, CLS. · Identify the biggest contributor to your slow metric (image size, render-blocking JS, font loading, server TTFB). · Apply the specific fix from the action above. · Re-test in PageSpeed and check GSC → Core Web Vitals after 28 days for real-user data. · Pro tip: Lab data is a debugging tool. Field data (GSC, CrUX) is what Google ranks on. Optimize for field. - Avoid: Optimizing for lab scores (PageSpeed) instead of field data (CrUX, GSC) · Lazy-loading the LCP image (defeats the optimization) · Using a polyfill for AVIF instead of a native <picture> fallback · Skipping the fix because "we're already fast" — measure, don't assume - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 318. Submit an accurate Google Merchant Center feed; fix all feed disapprovals - [ ] 319. Add breadcrumb + BreadcrumbList on all product/category pages - [ ] 320. Add FAQ + genuine Q&A per product for long-tail + snippet coverage - _Applies to the 3 actions above._ - How: Audit your URL structure: separate product, category, and filter URLs cleanly. · For products: unique title, unique description, Product + Offer schema, multiple high-res images, real reviews. · For categories: unique intro content (not just a product grid), curated links, faceted nav canonicalization. · Set up Product schema across your entire catalog and submit a Google Merchant Center feed. - Avoid: Letting faceted navigation create thousands of indexable URLs (tanks crawl budget) · Using the manufacturer's product description (duplicate content) · No Product schema on product pages · 404ing out-of-stock products instead of keeping them with alternatives - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 321. Show price, availability, and shipping clearly on-page (matches schema, aids CTR) - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 322. Deduplicate product variants (size/color) into one canonical with variant selectors - How: Open your site's root config (or CMS panel) for this surface — sitemap, robots.txt, .htaccess, or nginx config. · Apply the change as specified in the action above. · Test it: curl -I https://yoursite.com/... for the response code, or use GSC URL Inspection to verify Google can fetch the result. · Submit changes in GSC → Sitemaps or Coverage for re-crawl. - Avoid: Forgetting to test with curl or GSC URL Inspection · Blocking Googlebot from the path in robots.txt while also linking to it from the sitemap (conflicting signals) · Using a build-time timestamp instead of the real last-content-change date - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 323. Add related/complementary product internal links to spread equity and dwell - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 324. Speed-optimize PDPs/PLPs specifically (they carry commercial intent traffic) - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 325. Add user-generated content (reviews, Q&A, photos) — unique content + freshness - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 326. Keep URL structure stable across seasons; 301 retired category URLs - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. ## S · International _8 actions, #327–334_ Multiple languages or countries multiply every other problem on this list. hreflang, targeting and duplicate handling have to be right before anything else is worth doing. - [ ] 327. Add reciprocal hreflang tags for every language/region variant (each must list all others + itself) - [ ] 328. Include a hreflang="x-default" for the fallback/selector page - [ ] 329. Use correct ISO language-region codes (en-gb, es-mx); validate with an hreflang tester - [ ] 330. Keep hreflang URLs canonical, indexable, 200-status (no redirect/noindex targets) - _Applies to the 4 actions above._ - How: Open your site's root config (or CMS panel) for this surface — sitemap, robots.txt, .htaccess, or nginx config. · Apply the change as specified in the action above. · Test it: curl -I https://yoursite.com/... for the response code, or use GSC URL Inspection to verify Google can fetch the result. · Submit changes in GSC → Sitemaps or Coverage for re-crawl. - Avoid: Forgetting to test with curl or GSC URL Inspection · Blocking Googlebot from the path in robots.txt while also linking to it from the sitemap (conflicting signals) · Using a build-time timestamp instead of the real last-content-change date - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 331. Choose one geo strategy (ccTLD / subdirectory / subdomain); prefer subdirectories for consolidated authority - How: Identify what makes you credible: years of experience, certifications, published work, real client results. · Make it visible: author bio on every article, About page with real names, contact info. · Prove it: cite primary sources, link to your published work, mention specific projects. · Get external validation: media mentions, podcast appearances, bylines in industry publications. - Avoid: Generic "admin" byline without a real person attached · Fake credentials or exaggerated experience · No contact information (real address, real phone) · Missing or generic About page - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 332. Set country targeting for subdirectories/subdomains where needed - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 333. Don't auto-redirect by IP in a way that blocks Googlebot; use hreflang + optional banners - How: Open your site's root config (or CMS panel) for this surface — sitemap, robots.txt, .htaccess, or nginx config. · Apply the change as specified in the action above. · Test it: curl -I https://yoursite.com/... for the response code, or use GSC URL Inspection to verify Google can fetch the result. · Submit changes in GSC → Sitemaps or Coverage for re-crawl. - Avoid: Forgetting to test with curl or GSC URL Inspection · Blocking Googlebot from the path in robots.txt while also linking to it from the sitemap (conflicting signals) · Using a build-time timestamp instead of the real last-content-change date - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 334. Translate content genuinely (human/quality MT + review); avoid thin machine-translated duplicates - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. ## T · Spam avoidance and penalties _12 actions, #335–346_ The things that get sites demoted. Not edge cases — these are the patterns Google names explicitly in its own documentation. - [ ] 335. Serve the entire site over HTTPS with a valid cert; fix all mixed-content warnings - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 336. Remove hidden text, hidden links, and CSS-cloaked keyword blocks - How: Run PageSpeed Insights on a representative page. Note LCP, INP, CLS. · Identify the biggest contributor to your slow metric (image size, render-blocking JS, font loading, server TTFB). · Apply the specific fix from the action above. · Re-test in PageSpeed and check GSC → Core Web Vitals after 28 days for real-user data. · Pro tip: Lab data is a debugging tool. Field data (GSC, CrUX) is what Google ranks on. Optimize for field. - Avoid: Optimizing for lab scores (PageSpeed) instead of field data (CrUX, GSC) · Lazy-loading the LCP image (defeats the optimization) · Using a polyfill for AVIF instead of a native <picture> fallback · Skipping the fix because "we're already fast" — measure, don't assume - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 337. Serve identical content to users and Googlebot (no cloaking/user-agent switching) - [ ] 338. Remove keyword-stuffed, gibberish, or auto-generated spun content (leak: gibberish/spam scores) - _Applies to the 2 actions above._ - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 339. Remove doorway pages (near-identical pages targeting many cities/keywords) - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 340. Remove sneaky redirects and malicious/unexpected downloads - How: Open your site's root config (or CMS panel) for this surface — sitemap, robots.txt, .htaccess, or nginx config. · Apply the change as specified in the action above. · Test it: curl -I https://yoursite.com/... for the response code, or use GSC URL Inspection to verify Google can fetch the result. · Submit changes in GSC → Sitemaps or Coverage for re-crawl. - Avoid: Forgetting to test with curl or GSC URL Inspection · Blocking Googlebot from the path in robots.txt while also linking to it from the sitemap (conflicting signals) · Using a build-time timestamp instead of the real last-content-change date - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 341. Keep the site clear of hacked content/malware; monitor GSC → Security Issues - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 342. Disavow toxic/PBN/negative-SEO backlinks via GSC Disavow after manual review - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 343. Avoid thin affiliate pages with no added value; add original testing/opinion/data - [ ] 344. Label AI-assisted content with human review/editing; don't mass-publish unedited AI pages - [ ] 345. Avoid parasite/expired-domain abuse and scaled low-value content tactics (2024+ spam policies) - [ ] 346. Keep ads/affiliate disclosures compliant and non-deceptive; don't bury content under ads - _Applies to the 4 actions above._ - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. ## U · Analytics, monitoring and maintenance _14 actions, #347–360_ SEO is not a project that finishes. These actions set up the measurement that tells you whether the other 396 worked, and the monitoring that catches a regression before it costs a quarter. - [ ] 347. Verify the site in Google Search Console (all property variants) + Bing Webmaster Tools - [ ] 348. Set up GA4 with conversion/event tracking mapped to business goals - _Applies to the 2 actions above._ - How: Set up Google Search Console (free, 5 minutes). · Add Bing Webmaster Tools (free, 5 minutes). · Set up alerts: traffic drops, manual actions, CWV regressions, indexing errors. · Build a weekly review: 30 minutes, same day, same dashboard. Look at clicks, impressions, CTR, position by query. - Avoid: Setting up tracking and never looking at it · Not verifying site ownership in GSC · Too many tools without a clear question to answer · Ignoring manual actions in GSC (penalty trigger) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 349. Track rankings for target keyword sets (Ahrefs/SEMrush) with weekly snapshots - How: Sign in to Google Business Profile (or claim it). · Fill out every field. Pick the most specific primary category. Add relevant secondary categories. · Add photos weekly. Post GBP updates weekly. Respond to every review within 24-48 hours. · Build citations on the top 10 directories. - Avoid: Stuffing the business name with keywords · Buying reviews (Google detects IP/timing patterns) · Inconsistent NAP across directories · Ignoring review responses (especially negative ones) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 350. Monitor GSC Performance weekly: clicks, impressions, CTR, position by query + page - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 351. Set alerts for traffic drops, indexing errors, CWV regressions, and manual actions - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 352. Recrawl monthly (Screaming Frog) for new 404s, redirect chains, orphans, thin pages - How: Open your site's root config (or CMS panel) for this surface — sitemap, robots.txt, .htaccess, or nginx config. · Apply the change as specified in the action above. · Test it: curl -I https://yoursite.com/... for the response code, or use GSC URL Inspection to verify Google can fetch the result. · Submit changes in GSC → Sitemaps or Coverage for re-crawl. - Avoid: Forgetting to test with curl or GSC URL Inspection · Blocking Googlebot from the path in robots.txt while also linking to it from the sitemap (conflicting signals) · Using a build-time timestamp instead of the real last-content-change date - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 353. Audit Core Web Vitals field data monthly and fix any page group failing thresholds - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 354. Review Index Coverage monthly; investigate drops in indexed pages - How: Sign in to Google Business Profile (or claim it). · Fill out every field. Pick the most specific primary category. Add relevant secondary categories. · Add photos weekly. Post GBP updates weekly. Respond to every review within 24-48 hours. · Build citations on the top 10 directories. - Avoid: Stuffing the business name with keywords · Buying reviews (Google detects IP/timing patterns) · Inconsistent NAP across directories · Ignoring review responses (especially negative ones) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 355. Track backlink profile monthly for new links, lost links, and toxic spikes - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 356. Log every content update with date for freshness auditing - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 357. Benchmark top competitors quarterly (content depth, links, keywords) and close gaps - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 358. Maintain a redirect map; audit for chains/loops after any migration - How: Open your site's root config (or CMS panel) for this surface — sitemap, robots.txt, .htaccess, or nginx config. · Apply the change as specified in the action above. · Test it: curl -I https://yoursite.com/... for the response code, or use GSC URL Inspection to verify Google can fetch the result. · Submit changes in GSC → Sitemaps or Coverage for re-crawl. - Avoid: Forgetting to test with curl or GSC URL Inspection · Blocking Googlebot from the path in robots.txt while also linking to it from the sitemap (conflicting signals) · Using a build-time timestamp instead of the real last-content-change date - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 359. Run a full technical SEO audit quarterly against this checklist - [ ] 360. Keep a changelog of algorithm updates + your fixes to correlate ranking movements - _Applies to the 2 actions above._ - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. ## V · Gap-fill additions _13 actions, #361–373_ Actions that did not belong cleanly to a single section above, but that measured an effect and earned their place. - [ ] 361. Monitor Chrome UX Report (CrUX) field data (CrUX Dashboard / BigQuery / PSI); optimize the real Chrome-user experience — Chrome clickstream feeds Navboost (leak: chromeInTotal) - How: Set up Google Search Console (free, 5 minutes). · Add Bing Webmaster Tools (free, 5 minutes). · Set up alerts: traffic drops, manual actions, CWV regressions, indexing errors. · Build a weekly review: 30 minutes, same day, same dashboard. Look at clicks, impressions, CTR, position by query. - Avoid: Setting up tracking and never looking at it · Not verifying site ownership in GSC · Too many tools without a clear question to answer · Ignoring manual actions in GSC (penalty trigger) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 362. Treat each subdirectory as its own quality unit — Google scores quality per host "chunk" (leak: hostNSR/siteChunk); keep /blog, /shop, /docs uniformly strong and prune the weakest section so it doesn't drag the whole host - How: Audit your URL structure: separate product, category, and filter URLs cleanly. · For products: unique title, unique description, Product + Offer schema, multiple high-res images, real reviews. · For categories: unique intro content (not just a product grid), curated links, faceted nav canonicalization. · Set up Product schema across your entire catalog and submit a Google Merchant Center feed. - Avoid: Letting faceted navigation create thousands of indexable URLs (tanks crawl budget) · Using the manufacturer's product description (duplicate content) · No Product schema on product pages · 404ing out-of-stock products instead of keeping them with alternatives - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 363. Reduce quality VARIANCE, not just average — the leak scores per-site quality standard deviation (siteQualityStddev); raise or remove the weakest 10–20% of pages so the distribution is tight - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 364. Make the target entity the most SALIENT term on the page (leak: QualitySalientTerms): put it in the title, H1, URL, first 100 words, and an image alt; don't let a secondary term dominate frequency - How: Run PageSpeed Insights on a representative page. Note LCP, INP, CLS. · Identify the biggest contributor to your slow metric (image size, render-blocking JS, font loading, server TTFB). · Apply the specific fix from the action above. · Re-test in PageSpeed and check GSC → Core Web Vitals after 28 days for real-user data. · Pro tip: Lab data is a debugging tool. Field data (GSC, CrUX) is what Google ranks on. Optimize for field. - Avoid: Optimizing for lab scores (PageSpeed) instead of field data (CrUX, GSC) · Lazy-loading the LCP image (defeats the optimization) · Using a polyfill for AVIF instead of a native <picture> fallback · Skipping the fix because "we're already fast" — measure, don't assume - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 365. Structure long pages for PASSAGE ranking — each section self-contained with a descriptive heading + a standalone answer, so one passage can rank without the whole page - How: Open one of your most important pages. · Apply the change from the action above. · Test it renders correctly. Check the SERP preview using Google's results or a SERP simulator. · Track in GSC: did CTR change? Position? Wait 2-4 weeks for stable signal. - Avoid: Stuffing keywords into the title or H1 to "rank higher" — Google rewrites these · Using the same meta description across multiple pages · Having multiple H1s on a page · Writing titles >60 chars and letting them truncate in SERP - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 366. Add conversational long-tail Q&A phrasing for voice queries; mark eligible how-to/answer content with speakable schema - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 367. Keep a consistent publishing cadence (e.g. a weekly editorial calendar) — steady fresh output is a site-activity signal; avoid long dormant gaps followed by bursts - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 368. Build a Looker Studio dashboard joining GSC + GA4 (clicks, impressions, CTR, avg position, conversions by page/query) for a fixed weekly review - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 369. For review content, follow Google's Reviews System: first-hand testing evidence, unique photos/video, quantitative measurements, pros/cons, comparison to alternatives, and a clear verdict/winner - [ ] 370. For research/data pages, earn citations from Google Scholar–indexed papers, .edu, and .gov sources (strong topical-authority signal; leak: ScholarlyName) - [ ] 371. Optimize video retention/watch-time (hook in 5s, tight pacing, chapters, pattern interrupts) — watch metrics feed video ranking (leak: VideoContentSearchMetricStats) - [ ] 372. Add HSTS + security headers (Strict-Transport-Security, Content-Security-Policy, X-Content-Type-Options: nosniff, Referrer-Policy) for trust/safety - _Applies to the 4 actions above._ - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 373. Add knowsAbout + hasCredential/alumniOf to Person/Organization schema to model author & brand expertise explicitly - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. ## W · Field-level additions _37 actions, #374–410_ The largest late-stage section: actions added after testing on live sites, where the standard advice turned out to be incomplete or wrong. - [ ] 374. Add robots preview meta: max-snippet:-1, max-image-preview:large, max-video-preview:-1 (leak: RobotsInfo) - How: Run PageSpeed Insights on a representative page. Note LCP, INP, CLS. · Identify the biggest contributor to your slow metric (image size, render-blocking JS, font loading, server TTFB). · Apply the specific fix from the action above. · Re-test in PageSpeed and check GSC → Core Web Vitals after 28 days for real-user data. · Pro tip: Lab data is a debugging tool. Field data (GSC, CrUX) is what Google ranks on. Optimize for field. - Avoid: Optimizing for lab scores (PageSpeed) instead of field data (CrUX, GSC) · Lazy-loading the LCP image (defeats the optimization) · Using a polyfill for AVIF instead of a native <picture> fallback · Skipping the fix because "we're already fast" — measure, don't assume - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 375. Wrap physical addresses in an <address> HTML tag (leak: GeostoreAddressLinesProto) - How: Get a valid SSL cert (Let's Encrypt is free). · Redirect all HTTP to HTTPS site-wide. · Add HSTS: Strict-Transport-Security: max-age=31536000; includeSubDomains; preload · Add X-Content-Type-Options: nosniff and Referrer-Policy: strict-origin-when-cross-origin . · Test with SSL Labs — aim for A+. - Avoid: Expired SSL cert (Google explicitly demotes these) · Mixed content (HTTPS page loading HTTP assets) · No HSTS (allows SSL stripping attacks) · Open directory listings - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 376. Add mainEntityOfPage to page schema to declare the core entity/topic - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 377. Keep the raw HTML document modest in size; very large pages (>~500KB) risk "page size" downgrades - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 378. Keep the SSL cert valid and unexpired at all times — auto-renew + monitor expiry (leak: IndexingBadSSLCertificate = hard demotion) - How: Set up Google Search Console (free, 5 minutes). · Add Bing Webmaster Tools (free, 5 minutes). · Set up alerts: traffic drops, manual actions, CWV regressions, indexing errors. · Build a weekly review: 30 minutes, same day, same dashboard. Look at clicks, impressions, CTR, position by query. - Avoid: Setting up tracking and never looking at it · Not verifying site ownership in GSC · Too many tools without a clear question to answer · Ignoring manual actions in GSC (penalty trigger) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 379. Raise the text-to-HTML ratio: more visible content than markup/boilerplate on money pages - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 380. Store phone numbers in E.164 format (+14155550123) in schema and visible text (TelephoneNumber normalization) - [ ] 381. Split addresses into discrete schema fields: streetAddress, addressLocality, addressRegion, postalCode, addressCountry (never one text blob; leak: GeostoreAddressComponentProto) - [ ] 382. Add areaServed/serviceArea to LocalBusiness schema for delivery/service radius (leak: ServiceAreaProto) - _Applies to the 3 actions above._ - How: Identify the schema type matching your content ( Schema.org as reference). · Build the JSON-LD. Keep it minimal — only properties that match visible page content. · Place the JSON-LD in a single <script type="application/ld+json"> block in <head> . · Validate with Google's Rich Results Test and Schema.org validator . · Monitor in GSC → Enhancements for production errors. - Avoid: Adding schema that doesn't match visible page content (Google explicitly penalizes this) · Missing required properties (e.g., name on Product ) · Putting JSON-LD in the <body> instead of <head> · Generating schema with a tool that produces invalid markup - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 383. State parking + on-site amenities on local pages (leak: ParkingProto) - How: Sign in to Google Business Profile (or claim it). · Fill out every field. Pick the most specific primary category. Add relevant secondary categories. · Add photos weekly. Post GBP updates weekly. Respond to every review within 24-48 hours. · Build citations on the top 10 directories. - Avoid: Stuffing the business name with keywords · Buying reviews (Google detects IP/timing patterns) · Inconsistent NAP across directories · Ignoring review responses (especially negative ones) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 384. Restaurants: add hasMenu/servesCuisine and list dishes with descriptions (leak: FoodMenuItemOptionProto) - [ ] 385. Chains: use one consistent corporate legalName across every location page (leak: BusinessChainProto) - _Applies to the 2 actions above._ - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 386. Write declarative Subject–Verb–Object sentences ("Our tool does X", not "X is done by our tool") — leak: NlpSaft triples - How: Audit: list your 10 best pages. Score each on information gain vs the top 10 Google results. · Identify gaps: what are the top 10 missing that you could add? · Add at least one original data point, first-hand experience, or unique perspective none of them have. · Restructure for the user's task. Don't pad for word count. · Update the date and republish. Signal freshness. - Avoid: Writing 300-word rephrases of the top 10 results (no information gain) · Padding with generic "in conclusion" sections to hit a word count · Using stock photos for product reviews (Google's vision model can detect this) · Publishing AI-generated content without human review - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 387. Name entities explicitly/unambiguously ("Apple Inc." not "Apple"; "Dr. Jane Doe" not "she") — feeds Webref annotator + coreference - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 388. State entity relationships in plain text ("[Product] is made by [Brand]") to populate Webref entity relationships - How: Identify what makes you credible: years of experience, certifications, published work, real client results. · Make it visible: author bio on every article, About page with real names, contact info. · Prove it: cite primary sources, link to your published work, mention specific projects. · Get external validation: media mentions, podcast appearances, bylines in industry publications. - Avoid: Generic "admin" byline without a real person attached · Fake credentials or exaggerated experience · No contact information (real address, real phone) · Missing or generic About page - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 389. On first mention of a notable entity, link out to its authoritative page (Wikipedia/official) - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 390. If you must use stock photos, alter them (crop, text overlay, hue shift) to break the shared visual fingerprint (leak: StarburstVersionGroup) - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 391. Choose visually engaging hero images, not generic stock (leak: DeepImageEngagingness score) - [ ] 392. Ensure source images are large enough to index (≥~1200px long edge for hero/key images) - [ ] 393. Make PDF/scanned text selectable/OCR-able — never publish flat image-only PDFs for indexable content (leak: Goodoc) - _Applies to the 3 actions above._ - How: Run PageSpeed Insights on a representative page. Note LCP, INP, CLS. · Identify the biggest contributor to your slow metric (image size, render-blocking JS, font loading, server TTFB). · Apply the specific fix from the action above. · Re-test in PageSpeed and check GSC → Core Web Vitals after 28 days for real-user data. · Pro tip: Lab data is a debugging tool. Field data (GSC, CrUX) is what Google ranks on. Optimize for field. - Avoid: Optimizing for lab scores (PageSpeed) instead of field data (CrUX, GSC) · Lazy-loading the LCP image (defeats the optimization) · Using a polyfill for AVIF instead of a native <picture> fallback · Skipping the fix because "we're already fast" — measure, don't assume - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 394. Ensure high audio quality on videos so ASR transcripts are accurate (leak: AsrTranscriptRepair) - How: Record your video (or commission it). Minimum 720p, ideally 1080p. · Get a full transcript (auto-generated is fine, then edit). · Upload to YouTube with keyword-rich title, detailed description (with timestamps), relevant tags. · Embed on your own site with VideoObject schema and a visible transcript below. - Avoid: No transcript (Google can't rank what it can't read) · Boring first 30 seconds (most viewers drop off here) · Auto-generated YouTube thumbnail (low contrast, low CTR) · Uploading to YouTube but not embedding on your own site - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 395. Host on a clean IP; avoid shared hosting with spammy neighbor sites (leak: UrlPoisoningData) - [ ] 396. Register the domain multi-year and keep ownership stable; avoid expired/churn-and-burn domains (leak: RegistrationInfo) - _Applies to the 2 actions above._ - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 397. Grow backlinks gradually — avoid sudden anchor-velocity spikes (leak: LINK_SPAM_PHRASE_SPIKE) - [ ] 398. Vet referring domains for recent WHOIS/ownership changes; expect little value from expired-domain links (leak: anchor expired flag) - [ ] 399. Prioritize off-domain (external) links over internal for authority — external anchors weigh far more (leak: isLocal flag) - [ ] 400. Earn links from the trusted-seed tier (established news, .edu, .gov, recognized authorities) (leak: AnchorTrustedInfo) - [ ] 401. Don't rely on sitewide footer/template links — anchors beyond ~200 per (domain, text) pair are dropped (leak: RedundantAnchorInfo cap) - _Applies to the 5 actions above._ - How: Open one of your most important pages. · Apply the change from the action above. · Test it renders correctly. Check the SERP preview using Google's results or a SERP simulator. · Track in GSC: did CTR change? Position? Wait 2-4 weeks for stable signal. - Avoid: Stuffing keywords into the title or H1 to "rank higher" — Google rewrites these · Using the same meta description across multiple pages · Having multiple H1s on a page · Writing titles >60 chars and letting them truncate in SERP - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 402. Avoid DMCA/copyright strikes — repeated removals demote the whole domain - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 403. Put your top 4–6 pages exactly one click from the homepage to earn sitelinks (leak: QualitySitemapCoClickTarget) - How: Open your site's root config (or CMS panel) for this surface — sitemap, robots.txt, .htaccess, or nginx config. · Apply the change as specified in the action above. · Test it: curl -I https://yoursite.com/... for the response code, or use GSC URL Inspection to verify Google can fetch the result. · Submit changes in GSC → Sitemaps or Coverage for re-crawl. - Avoid: Forgetting to test with curl or GSC URL Inspection · Blocking Googlebot from the path in robots.txt while also linking to it from the sitemap (conflicting signals) · Using a build-time timestamp instead of the real last-content-change date - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 404. When updating evergreen content, keep the SAME URL (preserves accumulated anchors/history); don't spin up a new URL - How: Open one of your most important pages. · Apply the change from the action above. · Test it renders correctly. Check the SERP preview using Google's results or a SERP simulator. · Track in GSC: did CTR change? Position? Wait 2-4 weeks for stable signal. - Avoid: Stuffing keywords into the title or H1 to "rank higher" — Google rewrites these · Using the same meta description across multiple pages · Having multiple H1s on a page · Writing titles >60 chars and letting them truncate in SERP - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 405. Archive outdated pages with a visible "historical" notice instead of deleting, to preserve URL stability - [ ] 406. Use absolute, unambiguous dates on news/blog posts (no "yesterday"/relative dates) - _Applies to the 2 actions above._ - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 407. News: add unique commentary/expert quotes/local angle to escape near-duplicate NewsCluster suppression - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 408. E-commerce aggregators: expose the seller/offer count for multi-seller products (leak: MerchantAccountId) - How: Audit your URL structure: separate product, category, and filter URLs cleanly. · For products: unique title, unique description, Product + Offer schema, multiple high-res images, real reviews. · For categories: unique intro content (not just a product grid), curated links, faceted nav canonicalization. · Set up Product schema across your entire catalog and submit a Google Merchant Center feed. - Avoid: Letting faceted navigation create thousands of indexable URLs (tanks crawl budget) · Using the manufacturer's product description (duplicate content) · No Product schema on product pages · 404ing out-of-stock products instead of keeping them with alternatives - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 409. If you have an Android app, add Digital Asset Links + potentialAction (e.g. OrderAction) for app/voice actions - How: Identify a target publication or creator in your niche. · Build a relationship: comment on their work, share their content, quote them in yours. · Create a genuinely valuable asset worth linking to (original data, free tool, comprehensive guide). · Pitch: "I made this because of your work. Thought you might find it useful. No strings." · What doesn't work: cold outreach with no relationship, paid do-follow, link exchanges at scale, PBNs, blog comment spam. All penalty territory. - Avoid: Buying links (Google has called this a link scheme) · Exchanging links at scale · Getting links from PBNs (Private Blog Networks) — easy for Google to detect · Same anchor text on every link (manipulative pattern) - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate. - [ ] 410. Add geo.position/geo.placename meta + mention city/region naturally so Google scores geographic relevance (leak: CountrySalientCountry) - How: Audit your current state. What's the gap between where you are and where the action says you should be? · Implement the change. Start with your most-trafficked pages for highest leverage. · Test the result. Verify it works before scaling. · Document what you did. Next time, the same change should take half the time. - Avoid: Implementing without measuring the gap first · Skipping because the change feels small — small changes compound · Implementing once and never re-checking (Google's expectations evolve) · Not documenting the change so the team can't repeat or audit it - Verify: The change is live on the affected pages (test 2-3, not just your homepage). · Google can see it: use URL Inspection in GSC to re-crawl and check the rendered HTML. · The expected effect is happening. For content/schema, expect 2-4 weeks for ranking impact. For technical changes, often immediate.

How to install WordPress in 2026

Step 1: Choose a hosting provider

What to look for in WordPress hosting

per page containing the primary keyword/entity - How: Use the right HTML element for the right job:

for the page title (one per page) ·

for major sections ·

Installation