How the 6 CRO Modules Score Landing Pages in SEO Machine

SEO Machine evaluates landing pages using six specialized CRO modules that analyze everything from above-the-fold content to trust signals, aggregating results into a 0-100 score with a letter grade and publishing readiness flag.

The LandingPageScorer class in the TheCraigHewitt/seomachine repository orchestrates this analysis. According to the source code in data_sources/modules/landing_page_scorer.py, each module examines specific conversion-rate-optimization criteria, applies page-type-specific weights, and returns actionable recommendations alongside numeric scores.

Overview of the CRO Scoring Architecture

The scoring pipeline follows a three-stage process implemented within LandingPageScorer. First, _analyze_structure extracts structural metadata including word count, heading hierarchy, CTA count, and above-the-fold excerpts. Next, five specialized scoring helpers evaluate the content against CRO best practices. Finally, the overall scoring engine applies weighted aggregation, translates the result to a letter grade, and determines if the page meets publishing thresholds.

The system supports two page types with different weight distributions:

• SEO pages: Include all five category scores (Above-fold, CTA, Trust, Structure, SEO)
• PPC pages: Skip SEO analysis (weight redistributed to other modules) and focus purely on conversion elements

The Six CRO Modules Explained

Above-the-Fold Analyzer (_score_above_fold)

This module carries the highest weight for PPC pages (30%) and substantial weight for SEO pages (25%). It evaluates four critical criteria:

• Headline presence and quality
• Value proposition detection within initial viewport
• Call-to-action visibility above the fold
• Trust signal placement in the initial screen view

The analyzer uses regex patterns defined in the scorer to detect value propositions and conversion elements within the first portion of the markdown content.

CTA Analyzer (_score_ctas)

Matching the above-fold module in weight (30% PPC, 25% SEO), this helper analyzes:

• Total number of CTAs and their distribution (early vs. late placement)
• Alignment with the specified conversion goal (e.g., "trial" or "lead")
• Use of action verbs and benefit-focused language
• Presence of urgency or scarcity indicators

The implementation references conversion-goal-specific patterns to determine if CTAs align with the intended user action.

Trust-Signal Analyzer (_score_trust_signals)

Weighted at 25% for PPC and 20% for SEO, this module scans for social proof elements:

• Customer testimonials and reviews
• Social proof numbers (users, customers, results)
• Risk-reversal guarantees (money-back, free trial terms)
• Authority mentions and credentials
• Specific, quantified results (weighted as bonus points)

The detection relies on regex patterns compiled in the scorer to identify trust indicators that reduce friction in the conversion funnel.

Structure Analyzer (_score_structure)

This module applies 15% weight across both page types, evaluating content architecture:

• Word count against page-type-specific limits
• H2 heading count and hierarchy
• Bullet list usage for scannability
• Bold highlight placement for key benefits
• Balance between benefit-oriented and feature-oriented language

Unlike the content-focused modules, structure analysis works primarily with the metadata extracted during the initial structure pass.

SEO Analyzer (_score_seo)

Exclusive to SEO pages (15% weight, 0% for PPC), this module verifies technical on-page elements:

• Meta title length and primary keyword inclusion
• Meta description length optimization
• Primary keyword presence in H1 tag
• Internal link count and distribution

For PPC landing pages, this module returns None and its weight redistributes to conversion-focused modules.

Overall Scoring Engine (score)

The aggregation module performs final calculations:

1. Multiplies each category score by its page-type-specific weight
2. Sums weighted scores and rounds to one decimal place
3. Calls _get_grade to map 0-100 scores to letter grades (A-F)
4. Sets publishing_ready to True only when overall score ≥ 75 and no critical issues exist
5. Collates critical issues, warnings, and suggestions into prioritized lists

Weighted Aggregation and Final Grade

The scoring matrix differs significantly between page types to reflect distinct goals:

Module	SEO Weight	PPC Weight
Above-the-Fold	25%	30%
CTA	25%	30%
Trust Signals	20%	25%
Structure	15%	15%
SEO	15%	0%

The score method in LandingPageScorer handles this weighting dynamically based on the page_type parameter passed during instantiation. Critical issues from any module automatically disqualify a page from publishing readiness, regardless of numeric score.

Working with the LandingPageScorer

Basic Page Scoring

The high-level score_landing_page helper provides one-line access to the full analysis pipeline:

from data_sources.modules.landing_page_scorer import score_landing_page

sample_md = """# Launch Your Product in Minutes, Not Months

**Meta Title**: Easy Product Hosting | Start Free Today - Acme
**Meta Description**: Get started in minutes. Free 14‑day trial, no credit card required.
**Target Keyword**: product hosting

--- 

Ready to get started? [Start Your Free Trial →]

## What You Get

- Unlimited storage
- Automatic distribution
- Built‑in analytics
- 24/7 support
"""

result = score_landing_page(
    content=sample_md,
    page_type='seo',
    conversion_goal='trial',
    meta_title="Easy Product Hosting | Start Free Today - Acme",
    meta_description="Get started in minutes. Free 14‑day trial, no credit card required.",
    primary_keyword="product hosting"
)

print(result['overall_score'], result['grade'], result['publishing_ready'])

Accessing Individual Module Scores

Drill down into specific CRO performance areas using the category scores dictionary:

category = result['category_scores']
print("Above‑fold:", category['above_fold'])
print("CTAs:", category['ctas'])
print("Trust signals:", category['trust_signals'])
print("Structure:", category['structure'])
print("SEO (if applicable):", category['seo'])

Advanced Class-Based Usage

For customized analysis with different page types or conversion goals:

from data_sources.modules.landing_page_scorer import LandingPageScorer

scorer = LandingPageScorer(page_type='ppc', conversion_goal='lead')
full_report = scorer.score(
    content=sample_md,
    meta_title=None,  # Not evaluated for PPC

    meta_description=None,
    primary_keyword=None
)

print(full_report['overall_score'], full_report['critical_issues'])

Summary

• Six specialized modules analyze distinct CRO factors: Above-the-Fold, CTA, Trust Signals, Structure, SEO, and the aggregation engine.
• Page-type weighting adjusts scoring priorities: PPC pages ignore SEO metrics and weight conversion elements at 85% combined, while SEO pages balance technical and conversion factors.
• Publishing readiness requires a score ≥75 with zero critical issues flagged across any module.
• Core implementation resides in LandingPageScorer within data_sources/modules/landing_page_scorer.py, exposing both high-level helpers and granular class-based interfaces.

Frequently Asked Questions

How does the above_fold_analyzer detect value propositions?

The analyzer searches the above-the-fold content excerpt (extracted during structure analysis) using compiled regex patterns that identify value proposition keywords, headline structures, and benefit statements. It combines pattern matching with CTA visibility checks to determine if the initial viewport contains sufficient conversion context.

Why do PPC pages skip SEO scoring entirely?

PPC landing pages prioritize immediate conversion over organic search optimization. Since paid traffic arrives via ad clicks rather than search rankings, the SEO module receives 0% weight and its 15% allocation redistributes to Above-the-Fold (30%) and Trust Signals (25%), reflecting the higher importance of immediate credibility and above-fold CTAs in paid campaigns.

What constitutes a "critical issue" that prevents publishing readiness?

Critical issues include missing above-the-fold CTAs on PPC pages, zero trust signals on high-intent pages, or SEO-critical failures like missing meta titles on SEO pages. The score method checks the aggregated critical list from all modules; any items present automatically set publishing_ready to False, regardless of the numeric score meeting the 75-point threshold.

Can I customize the conversion goal patterns for CTA detection?

Yes. When initializing LandingPageScorer directly, the conversion_goal parameter (e.g., 'trial', 'lead', 'purchase') modifies how the _score_ctas method evaluates call-to-action alignment. The scorer references goal-specific regex patterns and action-verb lists embedded in the module to match CTAs against the intended conversion objective.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}