aeo

Comparison pages that survive extraction

How to build an X vs. Y page an answer engine can lift from: verdict first, stated criteria, an HTML comparison table, per-use-case answers, and honest losses.

A comparison page survives extraction when its verdict is in the first two sentences, its criteria are named before they’re scored, its differences sit in a real HTML table, and it says which option wins for which situation, including the situations where yours loses. A page that builds suspense, hides the table behind tabs, or ends in “it depends” with no conditions gives an extractor nothing to lift.

“X vs. Y” is the question format that most rewards this structure, because the question has a short answer and a long one, and both are useful. The short answer is the verdict. The long answer is the criteria and the table. An answer engine pulling a passage for “is X or Y better for small teams” needs the verdict for that condition stated in a sentence it can quote, with the evidence nearby.

This post is about building that page. It uses a fictional product line throughout, the ARM-X9 and ARM-X7 robotic arms from the fictional Acme Robotics, because the same structure applies whether you’re comparing your own products, your product against a category alternative, or two approaches to a problem. It doesn’t name real products, and you shouldn’t need to either to follow it.

Why do comparison pages fail extraction?

Comparison pages fail extraction because they’re usually written for a reader who scrolls to the end, and the answer is at the end. The structural reasons, in the order they’re usually found:

  • The verdict is last. Three paragraphs of context, then the features, then “so which should you choose?” An extractor that splits the page into passages finds the verdict in a chunk with no context for what’s being compared. Chunking: why passages have to stand alone explains why that chunk reads as an orphan.
  • The table isn’t a table. A grid of <div> elements styled to look like a table, a screenshot of a spreadsheet, or check-mark icons with no text. A text extractor sees either nothing or a run of words with no row or column relationship.
  • The content is behind interaction. Tabs per product, “show all features” toggles, sliders. If the comparison only appears after a click that runs a script, crawlers that don’t execute JavaScript never see it.
  • The criteria are implicit. The page compares 30 features without saying which ones matter for whom, so there’s no passage that answers the question a person asked.
  • The comparison is one-sided. Every row is a win for the publisher. Readers discount it, and the page gives no honest passage to quote for the cases where the other option is the right one.

Where does the verdict go?

The verdict goes in the first sentence under the H1, stated as a conditional answer: which option, for whom, and the main reason. It’s the answer block for this page type, and the same 40–60 word target applies.

The ARM-X9 is the better choice for production lines that need payloads over 5 kg or a reach beyond 900 mm; the ARM-X7 is the better choice for benchtop work, labs, and teams that need to move the arm between stations, because it weighs half as much and runs on standard mains power.

That’s one sentence an answer can lift for “which is better,” and it carries both conditions. (The specifications are fictional, for illustration.) It doesn’t say “it depends.” It says what it depends on.

Write the verdict after the rest of the page. The table and criteria tell you what the conditional answer is; the verdict summarizes them. If you can’t write it in two sentences, the comparison isn’t finished.

How should the criteria be stated?

State the criteria as a short list before any scoring, with one line each on why that criterion matters. This does two things. It tells the reader what the comparison covers and what it doesn’t. And it gives the page a passage that answers “what should I look for when choosing between these,” which is often a separate sub-question of the same search.

Google’s guidance on writing high-quality reviews is written for reviews, but most of it applies directly: it recommends explaining “what sets something apart from its competitors,” covering “comparable things to consider, or explain which might be best for certain uses or circumstances,” and discussing “the benefits and drawbacks of something, based on your own original research.” Stated criteria are how you make that explicit.

Keep the list short. Five to eight criteria that decide the choice are more useful than thirty that describe both products. Put the long feature list lower on the page or on the product pages, and link to it.

How do you build the comparison table?

Build it as an HTML <table> with a header row, one row per criterion, one column per option, and values written as text with units. Tables and lists that survive extraction covers the markup; the comparison-specific rules are these:

CriterionARM-X9ARM-X7
Maximum payload12 kg4 kg
Reach1,300 mm850 mm
Weight34 kg17 kg
Power400 V three-phase230 V single-phase
Typical settingFixed production cellBenchtop, lab, mobile cart
Better forHigh payload, long reachPortability, standard power

All specifications are fictional, for illustration.

  • Criteria as rows, options as columns. Each row then reads as a self-contained comparison on one point, which is the unit an extractor can lift.
  • Values, not icons. “12 kg” survives extraction; a green check mark doesn’t. Where a feature is present or absent, write “Yes” and “No,” or better, what the feature actually does.
  • Units on every number. “4” in a payload row is ambiguous to a reader who only sees that cell. Numbers, units and dates that survive extraction covers formatting.
  • A “better for” row. It turns the table into an answer as well as a dataset, and it repeats the verdict in a form that survives being separated from the opening paragraph.
  • One table per comparison. Splitting the same comparison across several tabbed tables breaks it into pieces that don’t stand alone.

Prices are the exception that needs extra care. If the page compares prices, keep them in text, date them, and keep them in sync with the pricing page. Pricing pages on answer surfaces covers why a stale price on a widely-read page does more harm than a missing one.

Should a comparison page have one verdict or several?

Several, one per use case, each under its own question heading. A single verdict covers the main question. But people ask the comparison with a condition attached: for a small team, on a budget, for a regulated industry, as a replacement for something else. Each condition is a separate query, and query fan-out means one question can pull in several of them at once.

The structure that handles this is a short section per use case:

  • H2 as the conditional question. “Which is better for a lab with no three-phase power?” Question headings vs. keyword headings covers why the question form helps.
  • First sentence is the answer. “The ARM-X7, because it runs on standard 230 V single-phase power and the ARM-X9 doesn’t.”
  • Two or three sentences of evidence. Pulled from the table, so the section stands alone without it.

Three to six use-case sections is typical. If you find yourself writing a section where both options are equally good, say so in the first sentence and name the criterion that should decide it instead.

How honest does the page need to be?

Honest enough that the page states, in a quotable sentence, the cases where the other option is the better choice. That’s partly an integrity rule, and partly a structural one: a page where every verdict favors the publisher has no passage that answers the question for the reader the other option suits. That reader still asks the question, and the answer will come from someone else’s page.

Practical rules:

  • Give every option at least one “better for” condition that’s true. If an option is better for nothing, it isn’t a real alternative and the page is a product page dressed as a comparison.
  • Compare like with like. Same tier, same date, same conditions of use. A current product against a competitor’s discontinued one is a comparison readers will notice.
  • Date the page and the data. Comparisons go stale as products change. Show when the comparison was last checked, and change that date only when the comparison actually changes.
  • Source the claims you didn’t measure. If a figure about the other option comes from its documentation, link to that documentation.

When the comparison is between your product and a category alternative rather than a named competitor (a robotic arm against manual assembly, a desktop tool against a hosted service), the same rules apply. The alternative still gets its “better for” conditions.

How do you audit comparison pages across a site?

Find them first, then check each against four questions. Comparison pages usually share a URL pattern (-vs-, /compare/, /alternatives/), so a crawler’s URL filter or a spreadsheet filter on the crawl export finds most of them without a terminal. Search Console’s Pages report filtered by those patterns gives the same list with traffic attached, which tells you which ones to check first.

For each page, by hand:

  1. Is the verdict in the first two sentences? Read the first paragraph under the H1 and nothing else. Can you say which option suits whom?
  2. Is the table a real table? View source and search for <table. If the comparison appears on screen but there’s no table element, it’s built from <div> elements or images.
  3. Is everything visible without a click? Turn off JavaScript in the browser and reload. Anything that disappears is invisible to crawlers that don’t render scripts.
  4. Does every option win somewhere? Scan the “better for” row and the use-case headings.

If your crawler supports custom extraction, extract the count of <table> elements and the first paragraph under the H1 for each matching URL, then review them in a spreadsheet. A comparison page with zero tables or a first paragraph that doesn’t name either option goes on the fix list.

In GEOBee, two of the AEO signals map onto this directly: the answer block check looks for a concise direct answer near the top, and the lists and tables signal checks for structures that can be lifted cleanly (weights are on the three lenses). They check the structure, not whether the verdict is fair. That part still needs a reader.

None of this decides which comparison an answer engine quotes. It makes sure that when your page is retrieved, the verdict, the evidence, and the conditions are each in a passage that can be lifted on its own. For the page-level principles behind it, see Answer Engine Optimization: a page-level guide. To check the structure of every comparison page on your site in one crawl, download GEOBee and run the 7-day trial.

On this page