How do I test whether my heading structure works?

Strip the page down to the headings and read them in order. A working outline reads as a table of contents that a stranger could use to decide whether the page answers their question. A broken one reads as a set of clever fragments that mean nothing without the text under them.

Should headings contain keywords?

They should contain the words that describe the section, which usually means the words someone would search, without engineering it. A heading written for a query rather than for the section under it produces an outline that describes a page other than the one you wrote.

Does the heading outline matter for AI search?

More than for classic search, because it is how a document gets divided into passages. A system chunking your page for retrieval uses the heading structure to decide where one topic ends and the next begins, and a flat page with one heading arrives as a single undifferentiated block.

Your headings, read on their own, should be the article

Delete every paragraph on your page and read what is left. If the headings alone tell somebody what the page covers and in what order, the outline works. If they read as a list of topics with no argument, you have styled text rather than a structure.

The short answer

Read your headings with the paragraphs removed. If the sequence alone tells someone what the page covers and in what order, the outline works; if it reads as a list of teasers, it does not. Heading levels are a tree describing containment, not a scale of visual importance, and choosing them by font size is what breaks them.

ImportantAudit check · Heading organization

Read the outline with the paragraphs removed

This is the whole check and it takes a minute. Extract the headings in document order, indent them by level, and read them as a table of contents. Two pages, same subject, same length:

two-outlines.txt

a list of nouns                     an outline that argues
----------------------------------  ----------------------------------------
H1 Carbon steel knives              H1 Carbon steel knives
  H2 Introduction                     H2 Why carbon holds an edge longer
  H2 Background                       H2 The cost: it rusts in a day
  H2 Carbon steel                     H2 Sharpening a carbon blade
  H2 Stainless steel                    H3 Which grit to start on
  H2 Comparison                        H3 How to tell when it is done
  H2 Maintenance                     H2 Keeping rust off it
  H2 Conclusion                        H3 After washing
  H2 FAQ                               H3 In storage
                                     H2 When stainless is the better choice

The left column is not badly written. It is a page whose headings were chosen to label sections rather than to say anything, and the result is an outline you cannot navigate: three of those headings could contain the answer you want and none of them tells you which.

The right column answers questions in its headings. That has three consequences at once. A reader scanning for their problem finds it without reading prose. A person who lands mid-page knows where they are. And the heading itself is a statement that can be matched against a query, which is where the search value in this check comes from.

Notice what is absent from the right column: Introduction, Overview, Background and Conclusion. Those four are the reliable signature of a page written to a shape rather than to a subject, and removing them usually improves both the outline and the prose underneath.

Levels are a tree, not a type scale

The most common structural defect is a heading level chosen because of how big the text looked. Somebody wanted a smaller subheading, picked h4, and skipped h3 entirely. The page looks right and the tree is now malformed: an h4 following an h2 claims to be a child of something that does not exist.

The rules are short. One h1, naming the page. Each level below it may go one deeper than its parent, never two. A level may repeat as often as you like. And a level can jump back up any distance, because closing three sections at once is normal. So h2 then h4 is wrong, and h4 then h2 is fine.

What breaks it in practice is almost never authoring. It is components. A card component that renders its title as an h3 is correct inside an h2 section and wrong in the sidebar of a page whose last heading was an h4. The same component, the same markup, two different outcomes, and nobody is looking at the outline when they drop it in.

The fix is to make the level a prop, not a decision inside the component.

A component that hardcodes its heading level has hardcoded an assumption about where it appears. Take the level as an input, default it to something sensible, and let the page decide. It is a small change that stops the outline being a side effect of composition, and it is the only version of this fix that survives a redesign.

Style is a separate concern. If your h3 is too large in that context, that is a CSS problem, and choosing the wrong element to get the right font size is trading a structural defect for a visual preference.

An outline is a sequence, and one fetch returns a field

The check reads every heading in order and evaluates the tree they form. A single-page audit reports the first h1, which is enough to know whether a page has a top-level heading and not enough to say anything about the structure beneath it.

This one needs the full crawl

An outline is the sequence of every heading from H1 through H6 in document order, and a single-page fetch returns the first H1 with nothing underneath it.

The instant search on this site audits a single page, so rather than show you a verdict it cannot support, this guide sends you to the place the check actually runs.

Run the full audit, free

The narrower question of whether an h1 exists at all has its own check, and it is the one to fix first: there is no outline to organise without a root.

Does this affect AI search?

Substantially, and through a mechanism that is more mechanical than most of the AI answers on this site. Systems that retrieve passages have to split your document first, and heading boundaries are the most reliable split points available in HTML. A well-formed outline hands a chunker a set of sections that each have a subject. A flat page of eleven paragraphs hands it arbitrary character offsets.

The consequence is that your headings become the titles of your chunks. A chunk headed Which grit to start on arrives with its own subject attached, which is exactly what makes it retrievable for a question about grit. A chunk headed Background arrives labelled with nothing.

There is a second effect worth knowing. Because a jumped level implies a parent that is not there, a malformed tree can be reconstructed wrongly: content that belongs to one section gets attached to another, and a passage is retrieved under a heading it does not answer. That failure is invisible on the rendered page, which is why segmentation and this check keep pointing at each other.

Why the outline rates above the prose inside it

Heading organisation is Important and readability is a Refinement, which surprises people who assume the writing matters more than the labels on it. The reason is that this one has mechanisms behind it and readability has proxies. Headings are used to build a document outline, to generate the list and step formats in results, to split a page for retrieval, and to navigate by keyboard and by screen reader. Each of those is a concrete consumer.

It stays below Critical because nothing is excluded. A flat page with nine h4s is crawled, indexed and ranked. What it loses is eligibility for the result formats that read structure, and the ability of a scanning reader to find the part they came for, and neither of those removes the page from anything.

The rating is helped by how cheap the fix is. Renaming eight headings and correcting two levels is an afternoon, needs no new content and no data, and improves accessibility as a side effect. Findings with real consumers and a same-day fix are exactly what the middle of the scale is for.

Extracting your own outline in one command

You do not need a tool for this and you should not read it in a browser, because the browser shows you type sizes and the check is about the tree.

outline.sh

curl -s https://example.com/guides/carbon-steel \
  | tr '\n' ' ' \
  | grep -o '<h[1-6][^>]*>[^<]*' \
  | sed -e 's/<h\([1-6]\)[^>]*>/\1 /' \
  | awk '{ lvl = $1; $1 = ""; indent = ""
           for (i = 1; i < lvl; i++) indent = indent "  "
           printf "%sH%d%s\n", indent, lvl, $0
           if (lvl > prev + 1 && prev > 0)
             printf "%s   ^ jumped from H%d\n", indent, prev
           prev = lvl }'

Two things to look for in the output. Any line the script marks as a jump is a malformed branch. And then read the indented list aloud: if you cannot tell what the page argues from the headings alone, no level correction will fix that, and the work is renaming rather than restructuring.

Run it on a competitor for the query you want. Their outline is public, it takes five seconds to extract, and it tells you which questions they decided the page had to answer.

Questions this check raises

How do I test whether my heading structure works?: Strip the page down to the headings and read them in order. A working outline reads as a table of contents that a stranger could use to decide whether the page answers their question. A broken one reads as a set of clever fragments that mean nothing without the text under them.
Should headings contain keywords?: They should contain the words that describe the section, which usually means the words someone would search, without engineering it. A heading written for a query rather than for the section under it produces an outline that describes a page other than the one you wrote.
Does the heading outline matter for AI search?: More than for classic search, because it is how a document gets divided into passages. A system chunking your page for retrieval uses the heading structure to decide where one topic ends and the next begins, and a flat page with one heading arrives as a single undifferentiated block.