1. Introduction: The Invisible Engine Behind Search Rankings
A pattern we see on almost every redesign audit: the new site looks better than the old one, and organic traffic drops 20–40% within six weeks of launch.
The design wasn’t the problem. The site was rebuilt for people, and nobody checked what it looked like to a crawler. The new mega-menu was rendered client-side, so Googlebot saw fewer links. Old URLs were redirected to the homepage instead of their equivalents. Product pages that used to sit two clicks deep now sat five deep behind filtered category views. The hero image, a 1.8 MB WebP that loaded through a JavaScript slider, pushed Largest Contentful Paint past four seconds on mobile.
Search engines don’t rank screenshots. They rank what they can discover, render, understand, and trust:
| Layer | What the user experiences | What Googlebot experiences |
| Visual design | Typography, color, motion | Mostly irrelevant |
| Information architecture | Navigation and menus | Crawl paths and click depth |
| Internal links | “Read more” and related posts | How link equity (PageRank) flows |
| Content markup | Headings and layout | Semantic HTML hierarchy and structured data |
| Performance | “This feels fast” | Core Web Vitals field data |
Technical SEO is the discipline of making those two columns agree. It isn’t a checklist you run once before launch. It’s the foundation for crawl efficiency, page speed, user retention, and the algorithmic trust that every other SEO investment (content, links, digital PR) depends on.
This blueprint covers the four layers that matter most, in the order we work through them on client engagements: architecture → internal linking → structured data → design-level failure points. It ends with an audit checklist you can run this week.
2. Website Architecture & Crawlability
The Flat Architecture Rule (3 Clicks or Fewer)
Every revenue-critical page should be reachable within three clicks of the homepage. Google has never published this as a rule. It’s a heuristic, and it holds up because of two mechanics:
- Crawl prioritization: URLs closer to the homepage (usually your most-linked page) are discovered sooner and recrawled more often.
- Equity decay: Every hop dilutes the internal PageRank passed along. A page seven clicks deep gets very little of it.
Deep architecture (the problem):
Home → Shop → Category → Subcategory → Filter View → Page 4 → Product
(click depth: 6)
Flat architecture (the fix):
┌── Category A ──┬── Product A1
│ ├── Product A2
Home ───────────────────┼── Category B ──┼── Product B1
│ │ └── Product B2
│ └── Category C ──── Product C1
└── Featured / Best-sellers block ──── Top 20 products (depth: 2)
How to implement it:
- Use hub pages. Category and pillar pages should link directly to their children and not depend on paginated lists.
- Surface priority URLs from high-authority pages. A “Popular products” or “Start here” module on the homepage puts your most important pages at depth 2.
- Add HTML breadcrumbs. They create upward links on every page and make good BreadcrumbList schema (see Section 4).
- Don’t hide the hierarchy behind filters. If a subcategory only exists as ?color=red&size=m, it isn’t in your architecture as far as a crawler is concerned.
Field note: Run a crawl in Screaming Frog and sort by the Crawl Depth column. Any page that earns revenue and sits at depth 4 or deeper is a quick win. Usually one contextual link from a depth-1 page fixes it.
Crawl Budget Optimization
Crawl budget is a real constraint for large sites (roughly 10,000+ URLs, or sites that publish fast). For a 50-page brochure site it mostly isn’t. The waste patterns are the same at any size, though, and fixing them improves indexation speed everywhere.
The biggest crawl-budget drains we see:
- Faceted navigation producing near-infinite parameter combinations
- Internal search result pages that can be crawled
- Session IDs and tracking parameters in internal links
- Redirect chains and soft-404s
- Duplicate URL variants (http/https, www/non-www, trailing slash/no slash)
robots.txt: control crawling, not indexing.
User-agent: *
Disallow: /search
Disallow: /*?sessionid=
Disallow: /*?sort=
Disallow: /cart
Disallow: /checkout
Sitemap: https://www.example.com/sitemap.xml
Two mistakes we fix constantly:
- Blocking a URL in robots.txt does not remove it from the index. Google can still index a blocked URL, without content, if other pages link to it. To deindex a page, let it be crawled and serve noindex.
- Never block CSS or JavaScript. Googlebot renders pages. If it can’t fetch your stylesheets and scripts, it can’t see your layout, your lazy-loaded content, or whether the page is mobile-friendly.
Noindex vs. Canonical vs. Robots.txt: Choosing the Right Tool
| Situation | Correct tool | Why |
| Duplicate/near-duplicate of a page you want ranked (e.g., ?utm= variants, print versions) | rel=”canonical” | Consolidates signals onto the preferred URL |
| Page users need but search doesn’t (thank-you pages, thin tag archives, internal search) | <meta name=”robots” content=”noindex, follow”> | Removes it from the index while links still pass equity |
| Infinite URL spaces that waste crawl (sort orders, session IDs) | robots.txt Disallow | Stops the crawl before it starts |
| Permanently moved content | 301 redirect | Passes signals and updates the index |
Critical: Don’t combine Disallow with noindex on the same URL. If Googlebot can’t crawl the page, it never sees the noindex tag.
Canonical tags are hints, not directives. Google will ignore your canonical if other signals contradict it, for example if your internal links, sitemap, and hreflang all point to a different URL. Keep them consistent:
<link rel=”canonical” href=”https://www.example.com/services/technical-seo-audit/” />
Use absolute URLs, make every page self-reference, and only list canonical, indexable, 200-status URLs in your XML sitemap. A sitemap full of redirects and noindexed pages teaches Google to trust it less.
Clean URL Conventions
| Avoid | Use |
| /index.php?id=4471&cat=12 | /services/technical-seo-audit/ |
| /Blog/2024/03/My_Post_FINAL | /blog/internal-linking-strategy/ |
| /products/shoes/shoes-running-shoes-mens | /mens/running-shoes/ |
Rules: lowercase, hyphens rather than underscores, no dates unless the content is time-bound, short and descriptive, one trailing-slash convention enforced site-wide.
Mobile-First Indexing & Core Web Vitals
Google now crawls and indexes almost every site with its smartphone crawler. If content, links, or structured data exist on desktop but not on mobile (in a collapsed menu that’s never rendered, or a “desktop-only” module), as far as rankings are concerned, they don’t exist.
The three Core Web Vitals, measured from real Chrome users at the 75th percentile:
| Metric | Measures | “Good” threshold | Most common cause of failure |
| LCP (Largest Contentful Paint) | Loading | ≤ 2.5s | Slow server response, unoptimized hero images, render-blocking CSS/JS |
| INP (Interaction to Next Paint) | Responsiveness (replaced FID in March 2024) | ≤ 200ms | Long JavaScript tasks, heavy third-party scripts, bloated event handlers |
| CLS (Cumulative Layout Shift) | Visual stability | ≤ 0.1 | Images without dimensions, injected banners, late-loading web fonts |
Code-level fixes that move the needle:
<!– LCP: Preload and prioritize the hero image; never lazy-load it –>
<link rel=”preload” as=”image” href=”/img/hero.avif” fetchpriority=”high”>
<img src=”/img/hero.avif” alt=”Technical SEO audit dashboard”
width=”1200″ height=”630″ fetchpriority=”high”>
<!– CLS: Always declare dimensions so the browser reserves space –>
<img src=”/img/chart.webp” alt=”Crawl depth distribution”
width=”800″ height=”450″ loading=”lazy”>
/* CLS: Reserve space for late-loading embeds and ad slots */
.ad-slot { min-height: 250px; }
/* CLS: Prevent font-swap layout jumps */
@font-face {
font-family: “Inter”;
src: url(“/fonts/inter.woff2”) format(“woff2”);
font-display: swap;
size-adjust: 100%;
}
For INP, the usual offenders are third-party tags: chat widgets, heatmap tools, and five overlapping analytics pixels. Audit your tag manager every quarter. Every script has to justify its main-thread time.
Key takeaway: Core Web Vitals are a tiebreaker-level ranking signal, not a trump card. Their bigger value is commercial. Faster, stabler pages convert better and bounce less, which is easy to measure in your own analytics.
3. The Science of Internal Linking
How Internal Links Route Link Equity
External backlinks bring authority into your domain. Internal links decide where it goes once it’s there. Every page has a finite amount of equity to pass, split across its outbound links.
The strategic pattern:
[External backlinks]
│
▼
┌──────────────────┐ contextual links ┌────────────────────┐
│ High-authority │ ─────────────────────────▶ │ High-intent │
│ pages │ │ conversion pages │
│ (guides, data │ ◀───────────────────────── │ (services, pricing,│
│ studies, tools) │ supporting links │ product pages) │
└──────────────────┘ └────────────────────┘
Your most-linked content (original research, free tools, popular guides) rarely converts directly, and your money pages rarely earn links on their own. Internal linking connects the two.
To find your equity sources: in Ahrefs or Semrush, open Best by links (or Top pages by referring domains). Every page at the top of that list should link contextually to at least one commercial page.
Avoid link dilution:
- A page with 300 links in its mega-menu and footer passes very little through each one.
- Sitewide footer links to 40 location pages dilute equity without adding topical relevance.
- Prioritize links in the body copy. Google has said that links in the main content carry more contextual weight than boilerplate navigation.
Building Airtight Topic Clusters (Hub-and-Spoke)
A topic cluster is a pillar page covering a broad topic in depth, surrounded by cluster articles that each go deep on one subtopic, all linked in both directions.
┌─── Crawl budget optimization guide
│
├─── XML sitemap best practices
│
PILLAR: ───────┼─── Canonical tags explained
“Technical │
SEO Audit” ├─── Core Web Vitals fixes
│
├─── JavaScript SEO rendering
│
└─── Schema markup implementation
Cluster rules we enforce:
- Pillar → every spoke: The pillar links to every cluster article from relevant passages, not only from a link list at the bottom.
- Every spoke → pillar: Each cluster article links back to the pillar with descriptive anchor text, ideally early in the article.
- Spoke ↔ spoke where relevant: Link related subtopics to each other, such as canonical tags ↔ crawl budget.
- One primary keyword per URL: If two spokes target the same query, merge them. Keyword cannibalization splits equity and confuses relevance signals.
- Spokes point to the conversion page: The cluster should end at a commercial destination, such as a “Technical SEO audit service” page.
Anchor Text Optimization
Anchor text is one of the strongest relevance signals you control on your own site. Unlike external links, internal anchors carry little over-optimization risk, but variety still reads more naturally and covers more semantic ground.
| Anchor type | Example | Use it for |
| ❌ Generic | “click here,” “read more,” “this post” | Never as the only link to a page |
| ✅ Exact match | “technical SEO audit” | Primary link from the pillar |
| ✅ Partial match | “running a full technical audit” | Most contextual links |
| ✅ Descriptive/long-tail | “how to find orphan pages in Screaming Frog” | Spoke-to-spoke links |
| ✅ Branded/navigational | “our audit service” | CTAs and conversion paths |
Rule of thumb: a reader should be able to predict the destination page from the anchor alone. That standard happens to be good for accessibility too, since screen-reader users often browse a page’s links as a list.
Diagnosing and Fixing Internal Link Leaks
1. Orphan pages. Pages with zero internal links pointing to them. Google may find them through the sitemap, but they get almost no equity and are often treated as low-priority.
Diagnose: Connect Google Search Console and Google Analytics (GA4) to Screaming Frog through its API integrations, or crawl your XML sitemap, and compare discovered URLs against crawled URLs. Any URL that appears in GSC, GA4, or the sitemap but not in the crawl is an orphan.
Fix: Link it from its parent hub and from 2–3 related articles. If it doesn’t deserve links, it probably doesn’t deserve to be indexed either, so consolidate it or remove it.
2. Redirect chains and internal redirects.
/old-service → 301 → /services/seo → 301 → /services/seo/
Each hop costs crawl resources and adds latency. Fix: Update the internal link itself to point directly at the final 200 URL. Don’t depend on redirects for links you control. Then collapse the chain so legacy URLs go to the destination in one hop.
3. Infinite click depth. Calendar archives, paginated tag pages, and faceted filters can create crawl paths that never end. Fix: Disallow infinite parameter spaces in robots.txt, and link deep content directly from hubs so it doesn’t depend on pagination.
4. Links crawlers can’t follow. Googlebot follows <a href=”…”> elements. It does not reliably follow:
<!– Not crawlable –>
<span onclick=”location.href=’/pricing'”>Pricing</span>
<a href=”javascript:void(0)” onclick=”goTo(‘pricing’)”>Pricing</a>
<!– Crawlable –>
<a href=”/pricing/”>Pricing</a>
Key takeaway: Internal linking costs nothing and takes effect quickly. In our experience, a focused internal linking sprint (fixing orphans, adding contextual links from equity-rich pages, cleaning redirect chains) is one of the fastest ways to move pages that are stuck on page two.
4. Schema Markup & Structured Data: Speaking Googlebot’s Native Language
Raw HTML vs. JSON-LD
When Googlebot parses raw HTML, it has to infer meaning. Is “4.8” a rating, a price, or a version number? Is “Austin” a location or a person? Structured data removes the guesswork by stating entities and their relationships in the shared Schema.org vocabulary.
JSON-LD is Google’s recommended format because it sits in a single <script> block, separate from your visual markup. A redesign can’t accidentally break it the way inline Microdata breaks when someone refactors a template.
Set expectations correctly: Schema markup isn’t a direct ranking factor. It makes you eligible for rich results and helps Google understand entities. The payoff comes through higher click-through rate on the rankings you already have.
Step 1: Organization & LocalBusiness
Put this on the homepage (or sitewide) to establish your entity. Use LocalBusiness, or a more specific subtype such as ProfessionalService, Dentist, or Restaurant, if you serve customers at a physical location or within a service area.
<script type=”application/ld+json”>
{
“@context”: “https://schema.org”,
“@type”: “ProfessionalService”,
“@id”: “https://www.example.com/#organization”,
“name”: “Example Digital Agency”,
“url”: “https://www.example.com/”,
“logo”: “https://www.example.com/img/logo.png”,
“image”: “https://www.example.com/img/office.jpg”,
“telephone”: “+1-512-555-0142”,
“priceRange”: “$$”,
“address”: {
“@type”: “PostalAddress”,
“streetAddress”: “100 Congress Ave, Suite 400”,
“addressLocality”: “Austin”,
“addressRegion”: “TX”,
“postalCode”: “78701”,
“addressCountry”: “US”
},
“geo”: {
“@type”: “GeoCoordinates”,
“latitude”: 30.2639,
“longitude”: -97.7446
},
“openingHoursSpecification”: [{
“@type”: “OpeningHoursSpecification”,
“dayOfWeek”: [“Monday”, “Tuesday”, “Wednesday”, “Thursday”, “Friday”],
“opens”: “09:00”,
“closes”: “18:00”
}],
“sameAs”: [
“https://www.linkedin.com/company/example-digital”,
“https://www.facebook.com/exampledigital”
]
}
</script>
Implementation notes: NAP (name, address, phone) must match your Google Business Profile exactly. The @id lets other schema blocks refer to this entity without repeating it.
Step 2: Article & BreadcrumbList
Use these on every blog post. BreadcrumbList replaces the raw URL in the search snippet with a readable path, which mainly helps on desktop.
<script type=”application/ld+json”>
{
“@context”: “https://schema.org”,
“@graph”: [
{
“@type”: “Article”,
“headline”: “The Complete Technical SEO Blueprint”,
“datePublished”: “2026-10-14”,
“dateModified”: “2026-10-14”,
“author”: {
“@type”: “Person”,
“name”: “Jane Doe”,
“url”: “https://www.example.com/team/jane-doe/”,
“jobTitle”: “Lead Technical SEO Strategist”
},
“publisher”: { “@id”: “https://www.example.com/#organization” },
“image”: “https://www.example.com/img/technical-seo-blueprint.jpg”,
“mainEntityOfPage”: “https://www.example.com/blog/technical-seo-blueprint/”
},
{
“@type”: “BreadcrumbList”,
“itemListElement”: [
{ “@type”: “ListItem”, “position”: 1, “name”: “Home”,
“item”: “https://www.example.com/” },
{ “@type”: “ListItem”, “position”: 2, “name”: “Blog”,
“item”: “https://www.example.com/blog/” },
{ “@type”: “ListItem”, “position”: 3, “name”: “Technical SEO Blueprint” }
]
}
]
}
</script>
The author object with a real author page supports E-E-A-T. It ties the content to a person with verifiable expertise.
Step 3: Product with Reviews, plus FAQPage
Product schema is where rich results pay off most in e-commerce: price, availability, star ratings, and shipping details right in the SERP.
<script type=”application/ld+json”>
{
“@context”: “https://schema.org”,
“@type”: “Product”,
“name”: “Pro Trail Running Shoe”,
“image”: [
“https://www.example.com/img/pro-trail-1×1.jpg”,
“https://www.example.com/img/pro-trail-4×3.jpg”,
“https://www.example.com/img/pro-trail-16×9.jpg”
],
“description”: “Lightweight trail running shoe with a rock plate and 6mm drop.”,
“sku”: “PTR-2026-BLK”,
“gtin13”: “0123456789012”,
“brand”: { “@type”: “Brand”, “name”: “ExampleRun” },
“offers”: {
“@type”: “Offer”,
“url”: “https://www.example.com/mens/running-shoes/pro-trail/”,
“priceCurrency”: “USD”,
“price”: “139.00”,
“priceValidUntil”: “2026-12-31”,
“availability”: “https://schema.org/InStock”,
“itemCondition”: “https://schema.org/NewCondition”
},
“aggregateRating”: {
“@type”: “AggregateRating”,
“ratingValue”: “4.7”,
“reviewCount”: “214”
},
“review”: [{
“@type”: “Review”,
“author”: { “@type”: “Person”, “name”: “Marcus T.” },
“datePublished”: “2026-08-02”,
“reviewRating”: { “@type”: “Rating”, “ratingValue”: “5”, “bestRating”: “5” },
“reviewBody”: “Best grip I’ve had on wet rock. True to size.”
}]
}
</script>
FAQPage schema is still valid markup that helps machines understand your content, including AI-driven search features:
<script type=”application/ld+json”>
{
“@context”: “https://schema.org”,
“@type”: “FAQPage”,
“mainEntity”: [
{
“@type”: “Question”,
“name”: “How often should I run a technical SEO audit?”,
“acceptedAnswer”: {
“@type”: “Answer”,
“text”: “Run a full technical SEO audit quarterly, and a targeted crawl after every major deployment, migration, or CMS update.”
}
},
{
“@type”: “Question”,
“name”: “Does schema markup improve rankings?”,
“acceptedAnswer”: {
“@type”: “Answer”,
“text”: “Schema markup is not a direct ranking factor, but it makes pages eligible for rich results, which can significantly increase click-through rate.”
}
}
]
}
</script>
Reality check on FAQ rich results: Since August 2023, Google shows FAQ rich results only for well-known, authoritative government and health websites. For most businesses, FAQPage markup will not produce the expandable SERP dropdown it used to. Use it for semantic clarity, but don’t promise clients the visual result. Product, Review, Breadcrumb, Organization, LocalBusiness, Article, Event, Recipe, and Video markup still produce rich results reliably.
Schema Rules That Prevent Manual Actions
- Mark up only what’s visible on the page. Ratings, prices, and FAQs in JSON-LD must match on-page content.
- No self-serving reviews. Google won’t show review stars for LocalBusiness or Organization when you mark up reviews of yourself on your own site.
- Validate before and after deploying with Google’s Rich Results Test and the Schema.org Validator, then watch the Enhancements reports in Search Console.
How Rich Snippets Take Over the SERP
Compare a plain blue link with a result showing ★★★★★ 4.7 (214 reviews) · $139.00 · In stock · Free returns. The second one takes up more of the screen, answers buying questions before the click, and pre-qualifies the visitor. That’s why rich results tend to lift CTR at the same ranking position, and why the traffic they bring often converts better.
Field note: To measure schema impact properly, use a Search Console Search appearance filter (e.g., “Product snippets” or “Review snippets”) and compare CTR for affected pages before and after deployment, holding average position roughly constant. Don’t judge schema by raw traffic, which moves with seasonality.
5. Web Design Decisions That Silently Ruin SEO & Analytics
This is where design and engineering teams most often damage organic performance without noticing. Each of these decisions looks reasonable in a Figma review.
Modal Pop-Ups and Interstitials
SEO problem: Google’s intrusive interstitials guidance penalizes mobile pop-ups that cover the main content right after a visitor arrives from search.
Analytics problem: Pop-ups that fire on page load inflate exits and distort engagement metrics. If the modal’s close button isn’t tracked, you can’t tell whether a visitor dismissed it or gave up on the page.
Fix:
- Trigger on exit intent or scroll depth (e.g., 50%), not on load.
- On mobile, use a slim banner that takes up 15% of the viewport or less.
- Send popup_view, popup_close, and popup_submit as GA4 events so you can measure what the modal costs against what it returns.
Infinite Scroll
SEO problem: Googlebot doesn’t scroll like a user and doesn’t trigger scroll-based loading reliably. Products or posts that only appear after scrolling may never be discovered.
Analytics problem: A single “page view” now covers what could be dozens of content views, which wrecks pages-per-session and content attribution.
Fix: Back infinite scroll with real paginated URLs that work without JavaScript, and update the URL as the user scrolls:
<!– Each “page” of results has a crawlable, linkable URL –>
<a href=”/blog/page/2/”>Next page</a>
// Update URL and fire a virtual page view as each new chunk loads
history.pushState({ page: 2 }, “”, “/blog/page/2/”);
gtag(“event”, “page_view”, {
page_location: location.href,
page_title: document.title + ” – Page 2″
});
JavaScript-Heavy Navigation and SPAs
SEO problem: Navigation rendered client-side (React, Vue, Angular) depends on Google’s rendering queue. Menus that only render on hover or click, or that use <div onclick> instead of <a href>, may contribute no crawlable links.
Analytics problem: In single-page applications, route changes don’t reload the page. Without configuration, GA4 records one page view for the whole session, and every downstream metric goes wrong.
Fix:
- Server-side render (SSR) or statically generate (SSG) your primary navigation and content. Next.js, Nuxt, and Astro all support this.
- Make sure all navigation links are real <a href> elements in the initial HTML.
- In GA4, enable Enhanced measurement → Page changes based on browser history events, or push virtual page views from your router.
- Check with Search Console’s URL Inspection → View crawled page to see the rendered HTML Google actually received.
Button States and Un-Indexable Dynamic UI
Tabs, accordions, and “Load more” buttons are fine if the content is already in the DOM. Google indexes content hidden in tabs on mobile. The problem is content that’s only fetched after a click:
| Pattern | Indexable? |
| Accordion content in HTML, hidden with CSS | Yes |
| Tab content fetched via API on click | Usually not |
| “Load more” button with no paginated URL fallback | Content beyond page 1 is at risk |
| Content behind a login or required form | No |
For analytics, give every interactive element a stable id or data- attribute (e.g., data-track=”pricing-tab-annual”) so tag manager triggers survive redesigns. Triggers keyed to auto-generated CSS classes are the top cause of tracking that silently breaks after a deploy.
Visual Hierarchy vs. Semantic Hierarchy
Designers pick heading styles for how they look. Crawlers and screen readers read heading tags for structure. When those two disagree, both suffer.
Common mistakes:
- Several <h1> tags because “the hero text needs to be big”
- Headings chosen for font size: an <h4> used as a section title because it looked right
- Important text rendered as images or <div class=”big-text”>
The fix: separate presentation from semantics.
<!– Visual size controlled by class, semantic level by tag –>
<h1 class=”text-display”>The Complete Technical SEO Blueprint</h1>
<h2 class=”text-xl”>Website Architecture & Crawlability</h2>
<h3 class=”text-lg”>The Flat Architecture Rule</h3>
Design for F-pattern scanning: front-load headings and the first lines of paragraphs with keywords, keep line length around 60–80 characters, use 16px or larger body text on mobile, and break up long text with tables, lists, and callouts. These choices improve readability for people and give AI Overviews clean, extractable passages to cite.
Micro-Interactions, Dwell Time, and Behavioral Signals
Fast visual feedback (a button changing state within 100ms of a tap, skeleton loaders instead of blank screens, inline form validation) does two jobs:
- It improves INP directly. A good INP score means the page paints a response quickly, so acknowledging the tap right away while the slow work continues in the background improves the metric.
- It keeps users engaged. Users who get immediate feedback don’t rage-click, abandon, or bounce back to the SERP.
Google doesn’t publish “dwell time” as a ranking factor, and you should be skeptical of anyone who claims to know exactly how it’s weighted. However, testimony from the U.S. v. Google antitrust trial confirmed that Google uses aggregated user interaction data (the system known as NavBoost) in ranking. Pages that satisfy users, without pogo-sticking back to search, are on the right side of that system. Either way, longer engagement and lower bounce rate show up in your conversion rate.
// Immediate visual acknowledgment, then the expensive work
button.addEventListener(“click”, async () => {
button.classList.add(“is-loading”); // paints within one frame
await new Promise(requestAnimationFrame);
await submitForm(); // heavy work after the paint
button.classList.remove(“is-loading”);
});
6. Technical SEO Audit Checklist for Modern Websites
| Technical element | Common mistake | Expected business / SEO impact | Recommended diagnostic tool |
| Crawlability | CSS/JS blocked in robots.txt; important sections disallowed | Pages rendered incorrectly or not indexed; ranking loss | Search Console (robots.txt report, URL Inspection) |
| Indexation | Noindex left on after staging launch; indexed thin/duplicate pages | Sudden traffic loss, or index bloat diluting quality signals | Search Console Pages report, Screaming Frog |
| Site architecture | Revenue pages at click depth 4+ | Slow discovery, weak equity, underperforming money pages | Screaming Frog (Crawl Depth), Sitebulb |
| Internal links | Orphan pages, “click here” anchors, links to redirects | Wasted equity, weak relevance signals, crawl waste | Screaming Frog + GSC/GA4 API integration, Ahrefs Site Audit |
| Redirects | Chains, loops, and 302s used for permanent moves | Lost link equity, slower pages, crawl waste | Screaming Frog (Redirect Chains report) |
| Canonicalization | Canonicals pointing to redirected, noindexed, or non-200 URLs; missing self-referencing tags | Google picks the “wrong” URL to rank; duplicate content issues | Search Console URL Inspection (“Google-selected canonical”), Screaming Frog |
| XML sitemap | Includes redirects, 404s, or noindexed URLs; never updated | Lower sitemap trust; slower discovery of new pages | Search Console Sitemaps report, Screaming Frog sitemap crawl |
| Core Web Vitals | Unsized images (CLS), lazy-loaded hero (LCP), heavy third-party JS (INP) | Weaker page experience, higher bounce rate, lower conversion rate | PageSpeed Insights, Search Console CWV report, Chrome DevTools Performance panel |
| Mobile-first parity | Content, links, or schema missing from mobile version | Content effectively invisible to Google | Search Console URL Inspection (smartphone crawler), Chrome DevTools device mode |
| JavaScript rendering | Client-only navigation and content; links as onclick handlers | Uncrawled pages, delayed indexation | URL Inspection “View crawled page,” Screaming Frog JS rendering mode |
| Schema markup | Invalid JSON-LD; markup not matching visible content; self-serving reviews | Lost rich results; possible manual action | Rich Results Test, Schema.org Validator, GSC Enhancements |
| Analytics integrity | SPA without history-based page views; event triggers tied to dynamic CSS classes | Decisions based on wrong data | GA4 DebugView, Google Tag Assistant |
| Headings & semantics | Multiple H1s; headings picked for visual size | Weaker topical clarity; accessibility failures | Screaming Frog (H1/H2 tabs), WAVE, Lighthouse |
| HTTPS & duplicates | Mixed content; http/www variants resolving without redirects | Split signals, browser security warnings | Screaming Frog, curl -I checks, Search Console |
How to prioritize: Fix in this order: (1) anything blocking indexation, (2) anything wasting crawl or equity at scale, (3) Core Web Vitals on templates that drive revenue, (4) schema and enhancements. Template-level fixes come before page-level fixes. One corrected product template can fix 10,000 URLs.
7. Final Takeaway & Action Plan
Technical SEO is ongoing maintenance, not a launch task. Every deployment, CMS plugin update, new marketing tag, and design refresh can bring back problems you already fixed. The sites that stay on top of search treat technical health the way engineering teams treat uptime: monitored, owned, and reviewed on a schedule.
Your 30-day action plan:
- Week 1: Crawl and baseline. Run a full Screaming Frog crawl with GSC and GA4 connected. Export crawl depth, orphan pages, redirect chains, canonical conflicts, and indexation status. Record your current Core Web Vitals from Search Console.
- Week 2: Fix architecture and links. Bring every revenue page to depth 3 or less. Link orphans from their hubs. Point internal links directly at final URLs. Add contextual links from your five most-linked pages to your five most important commercial pages.
- Week 3: Deploy structured data. Add Organization/LocalBusiness sitewide, Article and BreadcrumbList on content, and Product/Review on commerce templates. Validate every template in the Rich Results Test.
- Week 4: Performance and tracking. Fix LCP and CLS on your highest-traffic templates, cut or defer third-party scripts, and verify in GA4 DebugView that page views and key events fire correctly.
- Ongoing: A monthly crawl, a quarterly full audit, and a mandatory technical SEO check in your deployment QA process.
Is Your Site Architecture Costing You Rankings?
Most sites we audit have the same three problems: revenue pages buried too deep, link equity piling up on pages that don’t convert, and schema that’s missing, broken, or not eligible for rich results. Fixing them rarely needs new content or new backlinks. It means making the site you already have readable to search engines.
Start with a technical SEO audit. Run the checklist above against your own site, or book a technical SEO audit with our team and get a prioritized, developer-ready roadmap covering crawlability, internal linking, Core Web Vitals, and structured data, ranked by expected revenue impact.
Your design may be finished, but if search engines can’t crawl and understand it, it won’t rank.