You audit answer-readiness on a large site by template, not by URL. Ten thousand pages are rarely ten thousand designs; they are a dozen templates filled with different copy. Sample each template by hand to learn what a good and a bad section look like, then use a crawler to pull the first paragraph under every heading across the whole site, and triage the result in a spreadsheet. The by-hand pass tells you what to look for. The crawl tells you where it happens.
This post is that workflow: how to group the URLs, what to read on the sample, the extraction rules that pull headings and their opening paragraphs, and the spreadsheet that turns ten thousand rows into a short list of template fixes and a longer list of copy edits. It sits under Answer Engine Optimization: a page-level guide, and it is the at-scale companion to the single-site walkthrough in the AEO audit, end to end.
None of the checks below measure whether a page is cited. They measure whether an extractor that lands on a section finds an answer where it would look for one. That is the part of the problem you control.
What does “answer-ready” mean for one section?
A section is answer-ready when the first sentence under its heading answers the question the heading asks, and that sentence makes sense with the rest of the page removed. How to write an answer block sets out the reasoning and the 40–60 word working range, which is our heuristic rather than a published rule. Question headings vs. keyword headings covers the heading half.
Turn that into four things you can check per section:
| Check | Pass | Fail |
|---|---|---|
| Heading states a question or a clear topic | ”How long does shipping take?" | "Overview”, “More info” |
| First element after the heading is a text paragraph | A p with a sentence in it | An image, a CTA button, a carousel, nothing |
| First sentence answers the heading | ”Standard shipping takes three to five business days." | "We’re proud of our fast shipping network.” |
| The answer stands alone | No “as mentioned above”, no undefined “it" | "As noted, it depends on the plan.” |
The first two are mechanical, so a crawler can check them. The third and fourth need a reader. The method below spends human attention only where the mechanical checks say it is needed.
Step 1: Group URLs by template
Start with a list of every indexable URL. Your XML sitemap is the easiest source; a crawler’s export of 200-status, indexable pages is the more honest one, because it includes what the sitemap forgot. Paste the URLs into column A of a spreadsheet.
In column B, assign a template. Most sites can do this from the URL path:
=IFS(REGEXMATCH(A2,"/blog/"),"article", REGEXMATCH(A2,"/products?/"),"product", REGEXMATCH(A2,"/docs/"),"docs", REGEXMATCH(A2,"/locations?/"),"location", TRUE,"other")
That formula works in Google Sheets; in Excel, use a lookup table of path prefixes and XLOOKUP on the first path segment. Then pivot on column B to count URLs per template. Anything in “other” with a large count is a template you have not named yet. Look at a few of its URLs and add a rule.
Where paths do not identify templates, a crawler can. Extract the body element’s class attribute, or a template-specific element such as a breadcrumb or a product price block, and group on that.
Step 2: Read a sample of each template by hand
For each template, open a handful of URLs: the ones with the most clicks in the Search Console Performance report, plus a few chosen at random from the template. There is no published sample size for this, and this post does not invent one. The aim is not a statistical estimate. It is to see the template’s structure with your own eyes before you write extraction rules against it.
For each sampled page, open view-source: and confirm that the headings and their paragraphs are in the raw HTML. If the copy appears only after scripts run, the extraction rules below will return blanks for a reason that has nothing to do with writing; JavaScript content and what never makes the trip covers that case.
Then read each H2 and the sentence under it, and note three things per template:
- The element that follows a heading. On some templates it is always a paragraph. On others it is a
divwrapper, an image, or a component. Your extraction rule has to match what is actually there. - The failure pattern. Product templates often open sections with a marketing line. Docs templates often open with a prerequisite note. Articles often open with a transition. One template usually has one dominant failure.
- Whether it is a template problem or a copy problem. If every product page’s “Specifications” section opens with an image, that is one template ticket. If articles fail in different ways, that is editorial work spread across many URLs.
Write those three notes on a second sheet tab, one row per template. That tab becomes the summary page of the audit.
Step 3: Extract headings and first paragraphs with a crawler
Most desktop crawlers let you add custom extraction rules by XPath or CSS selector, run them on every crawled page, and export the results as columns. Four rules cover answer-readiness:
| Column | XPath | What it returns |
|---|---|---|
| H1 | //h1 | The page’s H1 text |
| H2s | //main//h2 | Every H2 inside the main content |
| First element after first H2 | name((//main//h2)[1]/following-sibling::*[1]) | The tag name, such as p, div, figure |
| First paragraph after first H2 | (//main//h2)[1]/following-sibling::*[1][self::p] | The paragraph text, or blank if the next element is not a paragraph |
Set the text rules to extract text, not inner HTML. If your templates do not use a main element, replace //main with the container your templates actually use; the boilerplate ratio post explains why that container matters for extraction too.
To cover every H2, not only the first, change the index: (//main//h2)[2], [3], and so on, up to the number of sections your longest template carries. Alternatively, many crawlers can extract every match of a single rule into numbered columns. //main//h2/following-sibling::*[1][self::p] then returns the opening paragraph of every section, in order, blank where a section opens with something other than a paragraph. Check the column count against the H2 count, because a blank does not always produce its own column.
A word count for the opening paragraph can be computed in XPath 1.0 itself, which avoids pasting long text into spreadsheet formulas:
string-length(normalize-space(P)) - string-length(translate(normalize-space(P), ' ', '')) + 1
Replace P with the paragraph expression. On a blank paragraph it returns 1, so filter blanks first.
The terminal route does the same work for developers on the team: a script that fetches each URL, parses the HTML, and writes each H2 with its following sibling to a CSV. It is not required for anything below.
Step 4: Triage in a spreadsheet
Export the crawl and open it next to your template column. Add these columns:
| Column | Formula or rule | Why |
|---|---|---|
| Question heading | =REGEXMATCH(H2_cell, "\?$") or a starts-with check for how, what, why, when, can, does | Separates question headings from labels |
| Opens with paragraph | =next_element_cell="p" | The mechanical structural check |
| Opening words | The XPath word count above | Flags one-line teasers and wall-of-text openings |
| Dependency words | =REGEXMATCH(LOWER(para_cell), "^(as (mentioned|noted|above)|this|it|these|however)") | Flags openings that lean on earlier text |
| Read verdict | Yes, Partial, No, filled by a person | Only for rows the filters send to a reader |
Now pivot by template. For each template, count the sections that fail the structural check, the sections with a dependency word, and the sections whose opening is very short or very long. A template where nearly every row fails the same mechanical check is a template fix. Write one row for it on the summary tab and stop reading those rows individually.
What remains is copy: sections where the structure is fine but the first sentence may not answer the heading. Filter to those, sort by the page’s Search Console clicks, and read from the top. A reader marks Yes, Partial, or No. Reading the opening sentence and its heading is quick, and because the filters have already removed the structural failures, the reader’s time goes to the judgement only a person can make.
At the end you have two lists: a short list of template tickets, each affecting hundreds or thousands of URLs, and a ranked list of sections to rewrite. Prioritizing AEO fixes shows how to order both against page value and effort.
A worked example on a fictional retailer
The site and numbers below are fictional and exist only to show the shape of the output.
A retailer has 9,800 indexable URLs: 7,200 product pages, 1,900 category pages, 450 articles, 200 store-location pages, and 50 others. The sample shows that product pages put a full-width lifestyle image directly after every H2, category pages have no H2 at all, articles mostly open sections with a transition sentence, and location pages open with the store’s address.
The extraction confirms the sample. On product pages, the next-element column reads figure for almost every section, so the first-paragraph column is blank. That is one ticket: move the image below the opening paragraph in the product template. On category pages, the H2 column is empty, which is a separate ticket for a template that has no sections to answer from. Articles produce the long tail: the dependency-word filter flags a few hundred section openings for a reader. Location pages pass the structural check, and the address opening is a reasonable answer to a “Where is the store?” heading, so they need nothing.
The audit that started as 9,800 URLs ends as two template tickets and a few hundred sentences to rewrite.
How GEOBee fits in
GEOBee scores the same property per URL as part of its AEO lens. The answer block signal, weighted 20 of 100, checks for a concise, direct answer within the first few paragraphs, and the grid’s Answer column reads Yes, Partial, or No for every page (the three lenses, the Overview & grid). Crawl with the page limit set to All, scope the crawl with Include and Exclude path patterns if you want one template at a time, and export the grid as CSV (exporting data). The Answer, AEO, and Words columns drop straight into the triage sheet beside your template column.
GEOBee’s answer signal looks near the top of the page; it does not grade every section’s opening. Keep the extraction rules above for section-by-section work, and use the answer block checker when you want a second opinion on a single rewritten passage.
What the audit tells you, and what it doesn’t
A finished audit says which templates put something other than an answer under their headings, and which sections open with a sentence that does not answer the heading. Both are readable facts about the HTML, and both can be re-checked after a fix by re-running the same extraction.
It does not say which sections will be quoted. An assistant chooses passages for reasons that live outside your page: the question asked, the competing sources, its own retrieval. Answer-ready sections are a precondition you can verify, not an outcome you can promise.
To score answer-readiness for every URL on a site and export it to the spreadsheet above, download GEOBee. The 7-day trial covers full crawls and CSV export.