Skip to main content

HowTo Content Numbered Steps Format

Issue No: 177

Category: Content & Readability

Issue type: Warning

Priority: IMPORTANT

Description​

Verifies if step-by-step instructional content uses structured, sequential step numbering (e.g., "Step 1:", "Step 2:") to ensure optimal voice search list-reading behavior and proper association with Schema.org HowTo configurations.

How do we capture it​

  1. Fetch the raw page HTML using an HTTP GET request.
  2. Determine if the page is a How-To guide. The crawler identifies this by parsing for:
    • URL matching patterns such as /how-to/, /diy/, /help/, or /tutorial/.
    • Raw HTML containing JSON-LD or Microdata structured schema declarations indicating @type: HowTo or itemtype="http://schema.org/HowTo".
    • Main heading elements (<h1> or <h2>) containing terms like "How to", "Steps to", or "Guide to".
  3. Extract step blocks from the raw HTML structure. Steps are isolated using the following sequence:
    • Parse elements annotated with itemprop="step" or matching class attributes containing step.
    • If structured JSON-LD or Microdata exists, parse the step array nodes directly from the JSON/Microdata structures.
    • If no microdata/schema exists, parse standard procedural list items (e.g., sequential <li> elements nested under <ol>).
  4. Execute text content validation on each extracted step:
    • Strip inner HTML tags and comments to obtain clean text.
    • Apply regex validation pattern ^(?i)(Step\s+\d+[:.-]?|\d+[\.\):-]) to the start of the step text.
    • Calculate the total count of steps, the count of compliant steps, and verify mathematical continuity (e.g., verifying step sequential progression: $1 \rightarrow 2 \rightarrow 3$).
  5. Constraint: The crawler parses only the static raw HTTP response and static JSON-LD / Microdata schemas. It does not load or execute client-side JavaScript. If step items are dynamically generated, structured, or reordered via client-side scripts, the crawler will not evaluate them; such dynamically injected structures must be classified as a diagnostic limitation.

What to store​

FieldTypeComment
is_howto_pageBOOLEANIndicates if the page contains procedural how-to or instructional content.
howto_schema_detectedBOOLEANIndicates if Schema.org HowTo metadata is declared in raw HTML.
total_steps_detectedINTEGERTotal count of steps parsed in the target instruction block.
numbered_steps_countINTEGERNumber of steps that successfully match sequential numeric prefix formats.
numbering_compliance_ratioNUMERIC(5,2)Ratio of valid numbered steps to total detected steps (scale of 0.00 to 1.00).
first_non_compliant_stepTEXTRaw string content of the first step that failed sequential numbering validation.
step_extraction_methodVARCHAR(50)Parsing path used to retrieve steps (e.g., 'JSON_LD', 'MICRODATA', 'SEMANTIC_LIST').

Condition for trigger​

The issue is triggered if the page is verified as how-to content but fails to consistently structure the steps with sequential numbers.

  • Trigger Rule 1: Missing Step Number Prefixes

    • Target Field: numbering_compliance_ratio
    • Evaluation Logic: is_howto_page = TRUE AND numbering_compliance_ratio < 1.00 AND total_steps_detected >= 2
    • Severity: WARNING
    • Diagnostic Message: "How-to instructions lack uniform sequential numbering prefixes (e.g., 'Step 1:'). This breaks logical voice reading patterns and search parsing."

  • Trigger Rule 2: Complete Absence of Sequential Numbering

    • Target Field: numbered_steps_count
    • Evaluation Logic: is_howto_page = TRUE AND total_steps_detected >= 2 AND numbered_steps_count = 0
    • Severity: WARNING
    • Diagnostic Message: "No sequential step-numbering was found on this instructional page. Use clear prefix layouts like 'Step 1:', 'Step 2:' to optimize accessibility."

Sources​

Long description​

Modern search engines and voice assistant devices process instructions linearly to present structured snippets or execute step-by-step narration. For example, when a user asks a smart speaker for instructions, the device relies on clean step indicators to chunk the sequence cleanly. Without explicitly formatted identifiers, smart readers can merge consecutive steps, skip steps, or lose context.

Additionally, structured search crawlers match the on-page visual text with HowTo schema properties. If the on-page text uses ambiguous bullet formatting while the JSON-LD contains raw sequence integers, standard visual-to-metadata reconciliation algorithms can fail.

Common failure scenarios checked by the crawler:

  • Explicit microdata containing step schemas, but corresponding visible HTML headers omitting sequential formatting.
  • Step lists using non-sequential numbers (e.g., skipping from "Step 1" directly to "Step 3" due to visual content edits).
  • Reliance on modern CSS pseudo-elements (like counter-increment) to render numbers. Since a standard crawler does not execute layout trees or render CSS, the text values will appear unnumbered to search engines.

How to Fix​

  • Hardcode sequential step prefixes (e.g., "Step 1: ", "Step 2: ") directly into your visible HTML page content. Avoid relying exclusively on CSS counter() values or ordered-list index layouts.
  • Group all sequential instructional blocks inside semantic ordered list tags (<ol> and <li>).
  • If using Schema.org HowTo structured data, verify that the name or text properties of each step match the physical, visible step titles in the HTML exactly.
  • Ensure step numbering has logical progression starting at 1, with no duplicate or skipped step indices.