Technical SEO & content

The plumbing beneath everything organic

Technical SEO is the least glamorous and most decisive part of organic visibility. It's the infrastructure that lets search engines and AI find, understand and trust your site: crawlability, rendering, indexing, site architecture, performance and machine-readable structure. The analogy that sticks is plumbing and water — content is the water, and you can have the cleanest water in the world, but if the pipes are broken, nothing flows. The best-written page on the internet is worthless if Googlebot can't crawl it, render it, or decide to index it.

This is why technical issues get resolved first. A content strategy built on a broken technical foundation is effort poured into pipes that leak — pages that never get indexed, JavaScript that crawlers can't read, architecture so deep that important pages are rarely visited. We fix the foundation, then build content on top, because the order isn't a preference; it's a dependency. Findability comes before everything else organic.

Crawlability now feeds two systems

The biggest change in 2026 is that the technical foundation no longer serves only Google. A whole new category of AI crawlers now reads the web, and the load is significant — ChatGPT's crawler alone makes roughly 3.6x more requests than Googlebot. The chain is identical for both: a page that can't be crawled can't be indexed, can't rank, and can't be cited by an AI engine either. Crawlability is the single prerequisite that gates traditional search and AI visibility at once.

There's an important wrinkle: AI citation is decoupling from rankings faster than expected. Only about 38% of URLs cited in AI Overviews still rank in Google's top 10, down from 76% a year earlier — and AI-cited content tends to be about 26% fresher than organic results. So being technically crawlable and keeping content current now matters for visibility in places a top-10 ranking alone no longer guarantees.

Rendering: if a machine can't see it, it doesn't exist

A subtle but costly failure is content that humans see but machines don't. Both Googlebot and AI crawlers run limited JavaScript, so a page that builds its content with client-side scripts can look perfect in a browser and nearly empty to a crawler. Google's late-2025 rendering update raised the stakes further: pages returning non-200 status codes can be dropped from the rendering pipeline entirely. Server-side rendering or static generation is the clearest path to making your content visible to the widest range of crawlers.

This is exactly how this site is built and how we build for clients — server-rendered, clean status codes, content present in the HTML rather than assembled by scripts after load. It's the same principle that drives AI visibility: machines reward content they can read directly. Getting rendering right is invisible when it works and catastrophic when it doesn't, which is why we treat it as a foundational check, not an afterthought.

Architecture and internal links build authority

How your pages connect is one of the most underused ranking levers. Site architecture should be shallow — important pages reachable within about three clicks of the homepage — because pages buried deeper get crawled less often and accumulate less internal authority. Orphaned pages, with no internal links pointing to them, are effectively invisible no matter how good their content. Strong, descriptive internal linking distributes authority to your priority pages and tells both Google and AI how your content relates.

// Make the site findable, readable, and structured
{
  "crawl": "clean robots.txt, sitemap, no traps, AI crawlers allowed",
  "render": "server-rendered, 200 status, content in HTML",
  "architecture": "shallow (<=3 clicks), strong internal links",
  "clusters": "pillar + supporting pages = topical authority",
  "schema": "valid JSON-LD; entity + E-E-A-T signals",
  "performance": "LCP<2.5s, INP<200ms, mobile-first, HTTPS"
}

We map crawl paths, find and fix orphaned pages, clean up redirect chains that leak authority, and use descriptive anchors instead of "click here." It's unglamorous work, but it's how authority actually flows to the pages you want to rank — and increasingly, how AI systems infer which of your pages are the authoritative ones.

Content clusters: depth that earns authority

On the content layer, the structure that wins in 2026 is the topic cluster: a pillar page covering a core subject, surrounded by supporting articles that each link back to it. This does double duty. It signals topical authority to Google — proof you cover a subject in depth rather than with a single thin page — and it helps AI systems understand the conceptual relationships between your pages, which influences whether and how they cite you. Clusters turn scattered articles into a coherent body of expertise.

Content quality still has to clear the E-E-A-T bar — experience, expertise, authoritativeness and trustworthiness — and that's reinforced technically through entity consistency: schema that connects your brand, authors and topics so machines can verify who you are. We plan content as clusters mapped to the topics you should own, keep them current (since freshness now feeds AI citation), and structure each page to be both genuinely useful to a reader and cleanly machine-readable. Depth, structure and freshness together are what build durable organic authority.

Schema: the foundation, not the polish

Structured data used to be an optional finishing touch; in 2026 it's part of the foundation. Schema markup tells machines what your content is and how it relates — that this is an organization, this a person, this an article, these are connected — which makes you eligible for rich results and, more importantly now, easier for AI systems to interpret and cite. A technically clean site that machines can't interpret is a missed opportunity, so we treat valid, accurate schema as a build requirement.

Done right, schema reinforces everything else: Organization and SameAs markup builds entity consistency and E-E-A-T, FAQ and article markup makes content liftable into answers, and clean JSON-LD removes the guesswork for both Google and AI. It's the same structured-data discipline behind our GEO work — because the line between "technical SEO" and "being citable by AI" has largely dissolved, and the markup that helps one helps the other.

How we work

We build the organic foundation in dependency order — infrastructure first, content on top:

• Crawl & index: clean robots.txt and sitemaps, no traps, indexation managed, AI crawlers allowed.
• Rendering: server-side rendering and clean status codes so machines see your content.
• Architecture: shallow structure and strong internal linking that flows authority.
• Performance: Core Web Vitals, mobile-first, HTTPS as table stakes.
• Schema: valid JSON-LD, entity consistency and E-E-A-T signals.
• Content clusters: pillar and supporting pages that build topical authority, kept fresh.

The result is a site Google and AI can crawl, understand, trust and cite — the foundation that makes every other organic effort actually work. It pairs naturally with web design, which builds it in from the start, and with GEO/AEO, which turns this readable foundation into AI citations.

Frequently asked questions