Static website SEO: a technical playbook for pages that actually rank

Static sites consistently score 95 or higher on PageSpeed Insights. They serve pre-built HTML from a CDN edge in under 200 milliseconds. And yet, many of them sit in Google’s “crawled, not indexed” limbo for months. The problem is not speed. Static website SEO fails when speed is treated as the entire strategy, while structured data, internal linking, and content depth are left unfinished. This guide covers the technical foundations that actually move a static page from “fast but invisible” to “indexed and ranking,” with configurations you can apply today.

---

Why static sites have an SEO advantage (and where they fall short)

Static architecture gives you a measurable edge on the metrics Google cares most about. But that edge only matters if the rest of your SEO foundations are in place. Understanding both sides of this equation is the starting point for any serious optimization effort.

The Core Web Vitals edge

When a user requests a page from a static site, the server returns a pre-built HTML file. There is no database query, no server-side rendering step, and no template compilation. The file exists as-is on the CDN edge closest to the user, ready to deliver.

This architecture means static sites hit Google’s Core Web Vitals targets almost by default. The three metrics that matter are Largest Contentful Paint (how quickly the main content loads), Interaction to Next Paint (how responsive the page feels), and Cumulative Layout Shift (how much the layout moves during loading).

Metric	Target	Why static wins
LCP	< 2.5s	Files served from CDN edge, no TTFB penalty from server processing
INP	< 200ms	Minimal JavaScript means no main-thread blocking
CLS	< 0.1	All assets are sized at build time, so layout is predictable

Google confirmed Core Web Vitals as a ranking signal in 2021, and has steadily increased their weight since. A static site that scores 98 on PageSpeed Insights has a structural advantage over a WordPress site struggling at 55, provided everything else is equal.

The key phrase is “everything else is equal.” In practice, it rarely is.

Where static sites silently fail at SEO

The same simplicity that makes static sites fast also removes the guardrails that dynamic platforms provide. WordPress sites get automatic XML sitemaps via plugins like Yoast or RankMath. They get managed meta tags, schema injection, and “related posts” widgets that build internal links without the author thinking about it. Static sites have none of this unless you build it yourself.

This creates a pattern that is surprisingly common: a static site that loads in 200 milliseconds but has no sitemap, no structured data, no internal links beyond the navigation bar, and 800 words of generic content. Google crawls it, sees that it is fast, sees that it is thin, and declines to index it. The page sits in “crawled, currently not indexed” indefinitely.

If you are new to the architecture, our guide on what a static website actually is covers the fundamentals. For a deeper comparison of how static and dynamic approaches differ in practice, see our static vs dynamic website breakdown.

---

The technical SEO checklist every static site needs

Technical SEO for static sites comes down to three areas: making your pages discoverable by bots, delivering them efficiently, and serving them securely. None of these are difficult, but all of them require deliberate setup because there is no plugin to handle them for you.

XML sitemap and robots.txt

A sitemap is a machine-readable list of every page you want Google to index. Without one, crawlers rely on following links from your homepage, which means pages buried more than two or three clicks deep may never get discovered.

Most static site generators can produce a sitemap automatically during the build step. Astro uses the @astrojs/sitemap integration. Hugo generates one natively. Eleventy has community plugins like eleventy-plugin-sitemap. If you are deploying raw HTML files without a generator, use a free crawler tool to generate the file and upload it to your root directory.

Your robots.txt file tells crawlers which areas of your site to access and where to find the sitemap. A minimal configuration for a static site looks like this:

User-agent: *
Allow: /

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

Place this file at the root of your site. Every time you add or remove pages, verify that your sitemap reflects the change. An outdated sitemap that lists deleted pages wastes your crawl budget and creates 404 signals that erode trust over time.

Cache headers and compression

Default hosting headers are often wrong for SEO-relevant performance. Your HTML pages need to be re-validated frequently so Google sees updated content, while your static assets (CSS, JavaScript, images) should be cached aggressively because they change rarely.

A solid baseline for static sites:

Cache-Control: public, max-age=31536000, immutable   /* hashed assets (main.a1b2c3.css) */
Cache-Control: public, max-age=3600                  /* HTML pages */

Hashed filenames change on every build, so they can be cached for a year without risk of serving stale content. HTML pages use a shorter TTL so search engines pick up content changes within hours rather than days.

For compression, Brotli delivers 15-20% smaller files than gzip and is supported by all modern browsers and CDNs. If your host supports it, enable Brotli for text-based assets (HTML, CSS, JavaScript, SVG, JSON). The difference between Brotli and no compression can be 200-400 milliseconds on mobile connections. That is a meaningful LCP improvement.

HTTPS, HTTP/2, and the hosting baseline

SSL is non-negotiable for SEO. Google has used HTTPS as a ranking signal since 2014, and Chrome marks HTTP sites as “Not Secure” in the address bar. Every page on your site needs to load over HTTPS, including assets like images and fonts. Mixed content (HTTPS page loading HTTP resources) triggers browser warnings and undermines the security signal.

HTTP/2 multiplexing is particularly valuable for static sites that load many small assets (icon sets, font files, CSS modules). Instead of opening a separate connection for each file, HTTP/2 sends them all over a single connection. This reduces latency and improves LCP on pages with many above-the-fold resources.

Your hosting platform choice directly determines whether these features are available. CDN-backed hosts like Cloudflare Pages or Supadrop provision SSL automatically, serve over HTTP/2 by default, and handle Brotli compression at the edge. Self-hosted setups on a VPS or S3 bucket require manual configuration of certificates, server blocks, and compression modules.

---

On-page SEO that you have to do manually

On a dynamic CMS, plugins generate meta tags, enforce heading hierarchies, and prompt you to fill in alt text before publishing. On a static site, every on-page SEO element is your responsibility. This is both the challenge and the advantage: you have full control over what search engines see, with no plugin conflicts or bloated markup getting in the way.

Meta titles and descriptions that earn clicks

Your meta title is the single most influential on-page ranking factor. It tells Google what the page is about and tells searchers whether your result is worth clicking.

Keep titles under 60 characters. Include your primary keyword naturally, not as the first word if it feels forced. Add a modifier that signals freshness or specificity (a year, a format label, a benefit).

Before: “My Blog - Static Sites” After: “Static Website SEO: Technical Playbook (2026)”

The meta description does not directly affect rankings, but it heavily influences click-through rate. Write it as a micro-ad: 150 characters, a clear benefit, active voice. Tell the searcher exactly what they will get if they click.

In raw HTML, these go in the <head>:

<title>Static Website SEO: Technical Playbook (2026)</title>
<meta name="description" content="Actionable SEO strategies for static websites. Covers Core Web Vitals, crawlability, structured data, and on-page optimization." />

In Astro, Hugo, or Eleventy, you define them as frontmatter fields and let the layout template inject them into the <head> at build time. This approach is less error-prone because the values live next to the content rather than buried in a separate template file.

Header hierarchy as a ranking signal

Use exactly one <h1> per page. It should describe the page’s primary topic and include your main keyword if it fits naturally. This tells search engines the subject of the entire document.

Structure the rest of your headings as a logical outline. <h2> tags mark major sections. <h3> tags mark subsections within those sections. Never skip levels (jumping from <h2> to <h4> is a common mistake that confuses both readers and crawlers).

A well-structured header tree for a 3,000-word article might look like:

h1: Static Website SEO: Technical Playbook
  h2: Why static sites have an SEO advantage
    h3: The Core Web Vitals edge
    h3: Where static sites fail
  h2: Technical SEO checklist
    h3: Sitemap and robots.txt
    h3: Cache headers
  h2: On-page optimization
    h3: Meta tags
    h3: Image optimization

Bots parse this tree to understand topic relationships. Readers use it to skim and find what they need. Both outcomes improve your page’s ranking potential.

Image optimization beyond file size

Image optimization is more than compressing files. It is a combination of format selection, dimension declaration, loading strategy, and semantic description that together affect three ranking signals: page speed, visual stability, and image search visibility.

Use WebP or AVIF format instead of JPEG or PNG. WebP offers 25-35% smaller files at equivalent visual quality, and browser support is now universal. AVIF compresses even further but encoding is slower, making it better for hero images than bulk assets.

Always declare width and height attributes. Without them, the browser does not know how much space to reserve for the image, causing layout shifts as images load. This directly hurts your CLS score. Set loading="lazy" on every image that appears below the fold to defer loading until the user scrolls near it.

Write alt text that describes the image’s content for users who cannot see it. Alt text is also an indexing signal for Google Images. Be descriptive and specific, not keyword-stuffed.

<img
  src="/images/seo-checklist.webp"
  alt="On-page SEO checklist showing meta tags, headers, and image optimization steps"
  width="800"
  height="450"
  loading="lazy"
  decoding="async"
/>

---

Structured data for static sites

Structured data is machine-readable metadata that tells search engines what your page is about in a format they can parse directly. It powers rich results in SERPs (FAQ dropdowns, breadcrumbs, review stars, how-to steps) and increases your click-through rate by making your listing visually richer than plain blue links.

Why structured data matters more without a CMS

On WordPress, Yoast or RankMath inject Article schema, FAQ schema, and breadcrumb markup automatically. You fill out a form and the plugin generates the JSON-LD. On a static site, there is no form. You either add the structured data yourself or it does not exist.

This is not a cosmetic gap. Rich results generated from FAQ schema can increase CTR by 20-30% according to Google’s own case studies. Breadcrumb markup helps Google understand your site hierarchy and display it in search results. Article schema with a dateModified field signals content freshness, which influences how often Google re-crawls the page.

Without structured data, your static page competes with one hand tied behind its back. Every WordPress competitor on the SERP has schema injected automatically.

Implementing BlogPosting and FAQPage schema

The preferred format for structured data is JSON-LD, a JavaScript notation that you embed in a <script> tag in the page’s <head> or <body>. Google recommends JSON-LD over Microdata or RDFa because it is decoupled from the HTML structure and easier to maintain.

Here is a complete BlogPosting schema for a static site article:

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "Static Website SEO: Technical Playbook",
  "description": "Actionable SEO strategies for static websites.",
  "url": "https://yourdomain.com/blog/static-website-seo/",
  "datePublished": "2026-03-27",
  "dateModified": "2026-05-20",
  "wordCount": 4000,
  "author": {
    "@type": "Person",
    "name": "Your Name"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Your Site Name",
    "logo": {
      "@type": "ImageObject",
      "url": "https://yourdomain.com/logo.svg"
    }
  },
  "image": "https://yourdomain.com/blog/hero-image.webp"
}

For FAQ content, add a separate FAQPage schema with your questions and answers. Each question becomes a potential “People Also Ask” result in Google:

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Do static websites rank better than WordPress?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Static websites have a structural advantage for Core Web Vitals..."
      }
    }
  ]
}

Static site generators let you template these schemas from frontmatter data. In Astro, you define title, description, pubDate, and faqItems in your MDX frontmatter, then your layout component reads those values and generates the JSON-LD at build time. Every page gets correct, unique structured data without manual duplication.

Test every page with Google’s Rich Results Test before deploying. Invalid schema (missing required fields, wrong types) is silently ignored by Google, which means your structured data does nothing without you knowing.

---

Internal linking strategy for static sites

Internal links are the connective tissue of your site. They distribute page authority, help Google discover content that is not in your sitemap, and create the topical clusters that signal domain expertise. On dynamic platforms, plugins like “Related Posts” and sidebar widgets handle much of this automatically. On static sites, every internal link is a deliberate editorial decision.

Why internal links matter more than you think

Google uses internal links to understand your site’s hierarchy. A page that receives links from many other pages on your site is interpreted as more important than a page with no inbound links. This is why homepages rank so well: every page in the navigation links back to them.

Internal links also pass topical context through anchor text. When you link to a page about portfolio hosting for freelancers using that phrase as the anchor, Google associates those words with the target page. This reinforces the target’s relevance for related search queries.

For static sites in particular, internal linking is the primary mechanism for connecting content into topical clusters. A hub page about static hosting that links to spoke pages about specific platforms (like our guides to Tiiny Host alternatives or Netlify alternatives) signals that your site covers the topic comprehensively.

A practical linking framework

A reasonable target is 6 to 10 internal links per 3,000-word article, placed where they genuinely help the reader explore a related topic. Each link should use descriptive anchor text that tells both the reader and search engines what the target page covers.

Weak anchor text: “For more information, click here.”

Strong anchor text: “If you are new to the architecture, start with our guide on what a static website is and how it works.”

Avoid linking the same page twice in the same article. Google only counts the first link’s anchor text, so duplicates add no value. Prioritize linking to your most important pages (pillar content, landing pages, product pages) from every relevant post.

After writing any article, verify that every link resolves to a live, indexed page. Links to draft pages, deleted pages, or pages with noindex tags pass no authority and create dead-end paths for both users and crawlers.

---

Content quality signals that get static pages indexed

Technical SEO and page speed get a static site crawled. Content quality determines whether Google actually indexes it. Since the Helpful Content Update in 2022 (and its subsequent iterations), Google’s quality threshold for indexation has risen substantially. Pages that would have been indexed five years ago now sit in “crawled, currently not indexed” indefinitely if they do not meet the bar.

Why Google crawls but does not index thin static pages

“Crawled, not indexed” means Google visited your page, evaluated the content, and decided it does not add enough value to its index. This is a content quality signal, not a technical one. Your page loaded fast, your robots.txt allowed it, your sitemap listed it, and Google still said no.

Static sites are especially vulnerable to this because they are often built by developers or designers who focus on code quality and visual polish but treat the written content as an afterthought. The result is a beautifully designed page with 800 words of generic advice that exists on 50 other sites.

Common failure modes include: content that restates widely available facts without adding original perspective, articles that describe concepts without showing implementations, pages that read like they were written to rank rather than to teach, and thin content that covers a broad topic in fewer words than a single section deserves.

Signals that demonstrate expertise

Google’s E-E-A-T framework evaluates Experience, Expertise, Authoritativeness, and Trustworthiness. For static site content, the most actionable of these is Experience: showing that the author has actually done the thing they are writing about.

Concrete code examples, real configurations, specific tool names with versions, before-and-after performance screenshots, and measurable outcomes (“reducing our LCP from 3.2s to 1.1s by switching to WebP”) all demonstrate experience. These signals are hard to fake and easy for both humans and algorithms to recognize.

Author credibility also matters. A byline with a verifiable name, a linked profile, and a stated area of expertise carries more weight than “Team” or “Admin.” If you are writing about building free landing pages with QR codes, show that you have actually done it.

Word count is not a quality signal by itself, but it correlates with depth. For competitive informational queries, Google’s indexation threshold appears to be around 2,500 words in most niches. Below that, you need an exceptionally unique angle or a strong backlink profile to compensate.

The freshness signal for evergreen static content

Static pages are “publish once, serve forever” by nature. This is efficient, but it creates a freshness problem: Google sees a page with an unchanged dateModified field and deprioritizes it for queries where recency matters.

Update your structured data’s dateModified value every time you make a substantive revision. Add new data points, refresh examples, and replace outdated tool recommendations. Do not just change the date. Google can compare the cached version to the live version, and a date bump with no content change is a false freshness signal that erodes trust.

A good cadence for evergreen static content is one substantive update every six months: refresh statistics, add a new section, update screenshots, and verify that all internal and external links still resolve.

---

Putting it all together: a static site SEO workflow

Here is the complete workflow, from writing to deployment to monitoring. Follow these steps for every page you publish on a static site.

1. Build your page with proper HTML semantics. One <h1>, logical <h2>/<h3> nesting, semantic elements (<article>, <nav>, <footer>).
2. Write a unique meta title under 60 characters and a meta description under 155 characters. Include your primary keyword in both.
3. Add JSON-LD structured data. At minimum, use BlogPosting or Article schema with headline, datePublished, dateModified, author, and publisher. Add FAQPage if you have Q&A content.
4. Optimize all images. Convert to WebP, set explicit width and height, add descriptive alt text, use loading="lazy" for below-fold images.
5. Add 6-10 internal links with descriptive anchor text. Link horizontally to related articles and vertically to your homepage or product pages.
6. Generate and deploy your XML sitemap. Reference it in robots.txt. Verify it lists only live, indexable pages.
7. Deploy to a CDN-backed host with automatic SSL, HTTP/2, and Brotli compression. Compare your options in our Vercel alternatives guide or browse our full list of hosting platforms compared to Netlify.
8. Test with PageSpeed Insights and Google’s Rich Results Test. Fix any errors before submitting.
9. Submit the URL to Google Search Console for indexing. Monitor the “Coverage” or “Pages” report for status changes.
10. Update the content and dateModified field every six months. Refresh data, add new sections, and verify all links.

This workflow works regardless of whether you use Astro, Hugo, Eleventy, Next.js, or plain HTML. The principles are the same. The implementation details change with each tool, but the checklist does not.

Mastering static website SEO is less about speed optimization and more about disciplined execution of the fundamentals that dynamic platforms automate away. Static sites give you the fastest possible foundation. The work that separates a fast, invisible page from a fast, ranking page is structured data, internal linking, content depth, and consistent maintenance. Start with the technical checklist, build outward with quality content, and let the performance advantage compound over time.

---

Frequently asked questions