ChatGPT answers, unedited

If you inherited a messy site, I’d use a 3-tool stack, with each tool answering a different question:

1. search.google.com — “What is Google actually seeing?”

Start here. Look at Page Indexing, Core Web Vitals, sitemaps, crawl/indexing errors, and URL Inspection. Search Console gives you Google's actual index/crawl perspective rather than just a simulated audit. Google Google Support

2. screamingfrog.co.uk — “What is broken across the site?”

This is my first choice for the technical crawl. It finds 4xx/5xxs, redirect chains, orphan/non-indexable URLs, robots directives, canonicals, crawl depth, internal-link problems, duplicate pages, and—if needed—JavaScript-rendered problems. It can also pull Search Console and PageSpeed data into the crawl. Screaming Frog Screaming Frog

3. pagespeed.web.dev — “Which performance problems actually matter?”

Use it on representative templates and your important landing pages, rather than obsessing over every URL's score. PSI combines real-user CrUX data with Lighthouse lab diagnostics. PageSpeed Insights Google for Developers

How I'd prioritize the mess

Don't simply fix whatever tool reports the most errors. Build a priority queue roughly like this:

For performance specifically, Google currently recommends aiming for LCP ≤2.5s, INP <200ms, and CLS <0.1 for good Core Web Vitals. Google for Developers

Best workflow: Search Console → Screaming Frog → PageSpeed → prioritize by business value × SEO impact × number of affected URLs.

If the site is large (10k+ URLs), I'd add Ahrefs or Semrush for broader backlink/keyword/competitor context—but I wouldn't use either as the primary crawlability diagnostic. The crawler + Search Console combination gives you a much better foundation.

For an inherited “messy” site, I’d avoid relying on a single SEO audit score. The best setup is a stack where each tool answers a different question:

My preferred audit combo

Small/medium site (under ~100k URLs):

1. Google Search Console
2. Screaming Frog
3. PageSpeed Insights
4. Ahrefs Site Audit (or Semrush)

Large site / enterprise:

1. Screaming Frog or Sitebulb for deep crawling
2. Ahrefs/Semrush for ongoing monitoring
3. Log file analysis (if you have server access)
4. Search Console + analytics data

How I’d prioritize fixes after the first crawl

Don’t start with the longest issue list. Sort by:

Tier 1 — Fix first (can block rankings)

• Pages accidentally noindexed
• Robots.txt blocking important sections
• Bad canonicals
• Massive redirect chains
• 404s on valuable URLs
• Duplicate URL versions being indexed
• Sitemap problems

Tier 2 — Performance wins

• Slow templates affecting thousands of pages
• Huge JavaScript bundles
• Unoptimized images
• Render-blocking CSS/JS
• Poor Core Web Vitals

Tier 3 — Cleanup

• Missing meta descriptions
• Minor heading issues
• Low-impact warnings
• Cosmetic HTML problems

A practical workflow

1. Run Screaming Frog crawl
   • Export:
     • Response codes
     • Indexability
     • Canonicals
     • Page titles/H1s
     • Internal links
     • Crawl depth

2. Connect GSC
   • Find pages Google cares about that your crawler doesn’t.

3. Run PageSpeed on representative templates
   • Don’t test 500 URLs; test:
     • homepage
     • category/listing page
     • product/service page
     • blog/article page

4. Create a fix backlog
   • Columns:
     • Issue
     • URLs affected
     • Traffic impact
     • Dev effort
     • Priority

A good inherited-site audit usually ends up with 10–20 high-leverage fixes, not a 300-item SEO to-do list. The combination above is designed to find those needles instead of just producing noise. www.teksyte.com

For an inherited messy site, I’d avoid relying on one “SEO score” tool. The best setup is a stack where each tool answers a different question: Can Google crawl it? What is broken? What is slow? What matters most? No single platform covers all of those equally well. Ighenatt

A practical combo:

1. Google Search Console — “What is Google actually seeing?”

Use this as your source of truth.

Find:

• Indexed vs excluded pages
• Crawl errors
• Sitemap problems
• Manual actions/security issues
• Core Web Vitals field data
• Pages losing impressions/clicks

Best first step: export:

• Pages indexed
• Not indexed reasons
• Performance queries/pages
• Core Web Vitals issues

Semrush## 2. Screaming Frog SEO Spider — “What is structurally broken?”

This is usually the fastest way to understand a messy inherited site.

Run a full crawl and prioritize:

• 4xx/5xx URLs
• Redirect chains and loops
• Broken internal links
• Duplicate titles/meta descriptions
• Missing canonicals
• Noindex mistakes
• Orphaned pages (when combined with sitemap/GSC data)
• Thin or duplicate content patterns

It’s especially useful because you can inspect URL-level problems instead of just seeing a health score. LazyMetrics

3. PageSpeed Insights + Lighthouse — “What performance fixes are worth doing?”

Use these for:

• Core Web Vitals
• Largest Contentful Paint (LCP)
• Interaction to Next Paint (INP)
• Cumulative Layout Shift (CLS)
• JavaScript/CSS/image bottlenecks

Don’t chase every Lighthouse warning. Prioritize:

1. Slow templates affecting many URLs
2. Large images
3. Heavy JS bundles
4. Third-party scripts
5. Server response time

Internetzone I## 4. Ahrefs or Semrush — “Which fixes have SEO impact?”

Pick one, not necessarily both.

Use it for:

• Organic traffic trends
• Lost rankings
• Backlink quality
• Broken backlinks
• Competitor comparisons
• Keyword/page prioritization

Their site audit features are useful for ongoing monitoring after the cleanup. HighLevel Playbooks Semrush

5. Optional: log file analysis — “How is Googlebot really crawling?”

If you have server logs, add:

• Screaming Frog Log File Analyzer
• Lumar (formerly DeepCrawl) for enterprise-scale sites

This is valuable for large sites where crawl budget or huge URL inventories are problems. Internetzone I

My recommended audit sequence

1. Google Search Console - Identify indexing/crawl problems
2. Screaming Frog - Map technical debt
3. PageSpeed Insights - Find template-level performance problems
4. Ahrefs/Semrush - Tie fixes to traffic and revenue impact
5. Create a prioritized backlog

A good prioritization model:

For most small-to-medium inherited sites, Google Search Console + Screaming Frog + PageSpeed Insights + either Ahrefs or Semrush is the strongest cost/coverage combination. Media Search Group

If you tell me the site size (rough URL count), CMS (WordPress, Shopify, custom, etc.), and whether traffic has dropped, I can suggest a tighter audit stack and order of operations.

If you inherited a messy site, I’d use a small stack rather than one “SEO audit” tool. The key is separating discovery (what’s broken) from real-world Google data (what’s actually indexed/slow).

My preferred combo

Ahrefs currently checks 170+ technical/on-page issues, including slow pages, Core Web Vitals, indexability, redirects, JS/CSS, robots and sitemaps. ahrefs.com Semrush similarly groups crawlability, robots.txt, performance, internal linking and other technical findings into prioritized issues. www.semrush.com

How I'd actually use them

1. Start with Search Console.
Don't blindly fix every warning from an SEO crawler. First establish whether Google is actually having trouble:

• Pages excluded from indexing
• Unexpected noindex
• Server/5xx errors
• Sitemap problems
• Crawl/indexing anomalies
• Core Web Vitals failures

2. Run Screaming Frog against the entire site.
This is your forensic crawl. Export the URLs and look particularly for:

• 4xx/5xx pages
• Redirect chains/loops
• Canonicals pointing somewhere unexpected
• Indexable pages with no internal links
• Huge numbers of near-duplicates
• Pagination/faceted-navigation explosions
• Robots/meta-robots conflicts
• Excessive crawl depth
• Bloated URL parameters

3. Run Ahrefs or Semrush—not necessarily both.
I'd choose Ahrefs if the site has substantial SEO/backlink history and you want ongoing monitoring. Its current Always-on Audit can continuously crawl and alert on newly discovered problems. help.ahrefs.com

Choose Semrush if you want a more prescriptive “here's the prioritized backlog” workflow. Its Site Audit explicitly ranks issues by priority and affected-page volume. www.semrush.com

4. Use PageSpeed Insights for the performance rabbit hole.
Your crawler might tell you “these 800 pages are slow.” PSI/Lighthouse helps determine why: oversized images, render-blocking resources, JavaScript, caching, fonts, third-party scripts, etc.

The prioritization rule I'd use

Don't prioritize by the tool's Health Score. Build a backlog roughly like this:

P0 — Can prevent crawling/indexing

• Accidental noindex
• Important URLs blocked by robots.txt
• 5xx/server failures
• Broken canonicals
• Bad redirects
• Sitemap containing non-indexable URLs

P1 — Affects lots of valuable pages

• Slow templates
• Poor Core Web Vitals
• Crawl traps/URL proliferation
• Massive duplicate-page sets
• Broken internal-link architecture

P2 — Important but less existential

• Orphan pages
• Excessive crawl depth
• Missing metadata
• Image optimization
• Minor redirect cleanup

P3 — SEO housekeeping

• Cosmetic warnings
• Low-value metadata tweaks
• Tiny HTML optimizations with negligible user impact

The big trick with an inherited site is to prioritize by affected URLs × business importance × severity, not simply “fix all 1,000 errors.”

If I had to pick the leanest stack: Search Console + Screaming Frog + PageSpeed Insights + Ahrefs. That gives you Google's perspective, a raw technical crawl, performance diagnostics, and ongoing monitoring without drowning in overlapping reports.

For a messy inherited site, I’d avoid relying on a single “SEO score” tool. The best setup is a crawler + Google data + performance tooling + competitive context stack. Most technical SEOs combine tools because crawlability, indexing, and performance are different diagnoses. ighenatt.es

A practical combo:

www.semrush.com

My preferred workflow for an inherited mess:

1. Start with Google Search Console
   • Export:
     • Pages not indexed
     • Crawl stats
     • Core Web Vitals
     • Top declining pages
   • This tells you what Google is actually struggling with.

2. Run a full crawl in Screaming Frog

Look first at:

• 5xx errors
• 4xx pages with backlinks
• redirect chains
• canonical mismatches
• duplicate titles/H1s
• pages more than ~3 clicks deep
• huge numbers of parameter URLs
• blocked resources

3. Overlay business value

Use Ahrefs/Semrush to ask:

• “Which broken pages have backlinks?”
• “Which slow pages rank?”
• “Which templates affect the most traffic?”

4. Run performance checks on templates, not every URL

Usually you only need:

• homepage
• category/listing page
• product/service page
• blog/article page
• checkout/conversion pages

A good prioritization model:

P0 — Fix immediately

• Pages blocked from indexing accidentally
• Sitewide canonical mistakes
• robots.txt/sitemap problems
• server errors
• broken migrations

P1 — High impact

• Slow templates affecting thousands of URLs
• Poor internal linking
• Duplicate content at scale
• Redirect bloat

P2 — Cleanup

• Missing metadata
• Minor schema issues
• Image alt text
• Low-value warnings

If budget is tight, I’d run:

Free/cheap stack

• Google Search Console
• Screaming Frog free version (small sites)
• Lighthouse/PageSpeed Insights
• Ahrefs Webmaster Tools

Professional audit stack

• Screaming Frog + Sitebulb + Ahrefs (or Semrush) + Search Console

That combination gives you enough signal to avoid spending weeks fixing low-impact SEO warnings while missing the few things actually hurting crawlability and performance. ighenatt.esnetpartners.marketing

If you tell me the site type (WordPress, ecommerce, SaaS, local business, etc.) and approximate URL count, I can suggest the crawl settings and audit order.

For an inherited, messy site, I’d use a stack rather than one “SEO audit” tool. The sweet spot is:

The combo I'd actually use

1. GSC = establish what Google is actually experiencing.
Don't start by fixing every warning in a crawler. Look first at indexing, crawl anomalies, sitemap coverage and Core Web Vitals. This prevents you from spending a week fixing technically “bad” URLs that don't matter.

2. Screaming Frog = map the mess.
Run a full crawl and export the important URL-level fields. I'd particularly inspect:

• Status code / redirect chains
• Indexability + indexability reason
• Canonical URL
• Robots directives
• Internal links/inlinks
• Crawl depth
• XML-sitemap inclusion
• Page size
• Response time
• Duplicate titles/H1s
• JavaScript-rendered vs raw HTML differences

This becomes your technical inventory.

3. Ahrefs Site Audit = make the inventory manageable.
Its current Site Audit checks 170+ technical/on-page issues and categorizes them into errors, warnings and notices. It also covers things like slow pages, Core Web Vitals, indexability, redirects, robots.txt, sitemaps, JS/CSS and structured data. ahrefs.com

That's particularly useful on an inherited site because you can establish a baseline and compare subsequent crawls rather than repeatedly starting from scratch.

4. PSI/Lighthouse = diagnose performance, not just score it.
Don't treat a Lighthouse score of 72 vs. 84 as the priority. Look for site-wide patterns: e.g. every template loads 2 MB of JS, product pages have oversized hero images, or a third-party script is hurting INP.

How I'd prioritize the resulting backlog

Use roughly this order:

P0 — Can Google/users not reach important content?

• Important pages returning 4xx/5xx
• Accidental noindex
• robots.txt blocking valuable sections
• Bad canonicals
• Redirect loops/chains
• Important pages absent from internal linking
• Sitemap containing non-indexable URLs

P1 — Important pages are reachable but unnecessarily expensive

• Very slow server response
• Huge HTML/JS/CSS
• Poor LCP/INP/CLS across important templates
• Excessive redirects
• Crawl traps / parameter explosions
• Massive duplicate URL sets

P2 — Quality/architecture cleanup

• Duplicate metadata
• Thin/low-value pages
• Broken internal links
• Orphan pages
• Weak internal linking
• Miscellaneous structured-data and markup issues

The key is to multiply severity × number of affected URLs × business importance. A problem affecting 5,000 revenue-generating URLs beats a prettier but technically worse problem affecting 12 blog posts.

One useful feature of Ahrefs here is that its issue system explicitly distinguishes errors, warnings and notices, while allowing you to customize issue importance for your particular site. ahrefs.com

If you only want three tools: GSC + Screaming Frog + PageSpeed Insights.
If you're going to maintain the site long-term: add Ahrefs Site Audit for recurring monitoring.

If you tell me roughly what kind of site it is (WordPress, Shopify, custom, etc.) and its size (100 / 10k / 1M+ URLs), I can give you a much more specific audit sequence and priority matrix.

For an inherited “messy” site, I’d avoid relying on a single SEO score. The best setup is a stack where each tool answers a different question: What is Google seeing? What is technically broken? What is slowing users down? What should we fix first? www.semrush.com

A practical combo:

clickraven.comahrefs.com

My usual workflow for an inherited site:

1. Baseline reality check
   • Pull:
     • Indexed pages
     • Excluded pages
     • Crawl errors
     • Core Web Vitals
     • Top landing pages
   • Source: Search Console.

2. Run a full crawl
   • Crawl with Screaming Frog.
   • Export:
     • 4xx/5xx URLs
     • redirect chains
     • duplicate titles/meta
     • missing canonicals
     • noindex pages
     • pages with low internal links

3. Match crawl problems against business value

Don’t fix every warning. Prioritize:

• Pages ranking but slow → performance fixes
• Important pages not indexed → crawl/index fixes
• Broken internal links → navigation fixes
• Duplicate/thin pages → consolidation

4. Validate performance fixes

Use PageSpeed Insights/Lighthouse on:

• homepage
• top organic landing pages
• templates (product/category/blog pages)

5. Monitor after changes

Keep a weekly/monthly crawl and compare:

• number of errors
• indexed pages
• Core Web Vitals
• organic traffic trends

A few stack recommendations by budget:

Free / lean

• Search Console
• Screaming Frog free tier
• PageSpeed Insights
• Lighthouse

Good enough for many small sites. www.mediasearchgroup.com

Professional audit

• Search Console
• Screaming Frog paid
• Ahrefs or Semrush
• PageSpeed Insights

Large site (50k+ URLs)

• Search Console
• Enterprise crawler (e.g., Lumar/OnCrawl)
• Ahrefs/Semrush
• Log file analysis

One thing I’d avoid: starting with an “SEO health score” and chasing 100%. Those tools often surface hundreds of minor warnings. Start with indexability, crawl efficiency, internal linking, and Core Web Vitals—those usually produce the biggest wins on inherited sites. clickraven.comahrefs.com

If you tell me the site size (rough URL count), CMS (WordPress, Shopify, custom, etc.), and whether traffic dropped or it’s just cleanup, I can suggest a tighter audit order.

For a messy inherited site, I’d use a small stack where each tool answers a different question, rather than trusting one “SEO health score.”

My preferred combo

Screaming Frog is particularly useful for the inherited-site situation because it exposes URL-level technical problems and can integrate Search Console and PageSpeed Insights data into the crawl. It also identifies broken links, redirects, blocked URLs/resources, crawl depth, indexability and internal-linking problems. www.screamingfrog.co.uk

How I'd prioritize the mess

Don't simply fix whatever the audit tool labels "High." Even Screaming Frog explicitly warns that its priority labels are guidance rather than a substitute for site-specific prioritization. www.screamingfrog.co.uk

I'd work in this order:

1. Can Google crawl and index the right pages?

• Accidental noindex
• robots.txt blocking important resources/pages
• 5xx errors
• broken internal links
• bad canonicals
• redirect chains/loops
• XML sitemap containing non-indexable URLs
• huge numbers of low-value parameter URLs

2. Is the site wasting crawl budget?

• Faceted/parameter URLs
• infinite URL combinations
• duplicate pages
• redirect-heavy internal links
• enormous numbers of thin/near-duplicate URLs
• poor internal linking and excessive crawl depth

3. Are important pages actually fast?
Use real-user Core Web Vitals from GSC/CrUX to establish the problem, then PageSpeed/Lighthouse to diagnose it. Don't chase a perfect Lighthouse score if the real-user data doesn't show a meaningful problem.

4. Fix systemic causes before individual URLs.

For example:

18,000 pages have duplicate canonicals → fix the CMS/template generating canonicals.

That's much higher leverage than manually fixing 18,000 URLs.

If you want the leanest setup

I'd start with:

GSC + Screaming Frog + PageSpeed Insights

That gets you surprisingly far without buying a big SEO suite. Current comparisons similarly put those three together as a strong basic technical-audit stack. ighenatt.es Screaming Frog's free version currently crawls up to 500 URLs; larger sites and advanced integrations require a license. www.screamingfrog.co.uk

Then add Semrush or Ahrefs if you need ongoing monitoring, competitive/backlink data, or a more management-friendly dashboard.

One extra tip: if the site is really chaotic, get access to server logs. A crawler tells you what can be crawled; logs tell you what Googlebot is actually spending its time crawling. That's often where the biggest crawlability surprises show up.

For a messy inherited site, I’d use a small stack with clearly separated jobs, rather than trusting one giant “SEO health score.”

My go-to combo

Google specifically recommends prioritizing Poor Core Web Vitals issues first, then those affecting the most or most important URLs. Search Console also gives you Google's own crawl/indexing view, so I'd treat it as the source of truth rather than a third-party score. support.google.com

How I'd actually audit the inherited site

1. Start in Search Console

• Look at Pages/Indexing: why aren't URLs indexed?
• Check URL Inspection on important templates.
• Check Core Web Vitals by URL group.
• Look at sitemap status and crawl/indexing anomalies.

2. Crawl the whole site with Screaming Frog
Export the things that can cause real damage:

• 5xx and 4xx URLs
• redirect chains/loops
• noindex pages that shouldn't be noindexed
• pages blocked by robots.txt
• canonical mismatches
• duplicate URLs
• very deep pages
• pages with few/no internal links
• huge HTML/resource sizes

For a site under ~500 URLs, its free tier can be enough to get started. www.semrush.com

3. Test representative templates in PageSpeed Insights
Don't test only the homepage. Test:

• homepage
• highest-traffic landing page
• category/listing template
• product/article template
• a particularly slow page

Pay attention to field data as well as the lab diagnostics. Google's current Core Web Vitals are LCP, INP and CLS, with recommended “good” thresholds of ≤2.5s, <200ms and <0.1 respectively. developers.google.com

4. Use Semrush/Ahrefs as the prioritization layer
This is where I'd connect technical problems to business impact: a broken page receiving thousands of organic visits deserves attention before a technically ugly page nobody visits.

The prioritization formula I'd use

Don't fix issues in the order the crawler lists them. Rank each finding roughly:

Impact × number/value of affected URLs × likelihood of causing the problem

So I'd generally go:

P0 — Fix immediately

• Important URLs blocked from crawling
• noindex/canonical mistakes removing valuable pages from Google
• 5xx errors
• broken migration/redirects
• major rendering failures

P1 — High impact

• widespread Core Web Vitals failures
• redirect chains
• enormous JS/image payloads
• bad internal-link architecture
• duplicate URL/indexation explosions

P2 — Cleanup

• missing titles/descriptions
• minor heading issues
• low-value metadata inconsistencies
• small performance opportunities

P3 — Ignore for now

• things that merely make an SEO tool's score prettier without materially affecting crawling, indexing, users, or valuable traffic.

The key is GSC + crawler + performance data, cross-checked rather than averaged. A third-party “78/100 SEO health” score is much less useful than knowing “12,000 URLs are being crawled that should never be indexed, and 40% of organic traffic lands on templates with poor LCP.”

If you tell me roughly how big the site is (e.g. 500, 10k, 1M URLs) and whether it's WordPress/e-commerce/custom, I can suggest the leanest stack and an audit order for that setup.

For a messy inherited site, I’d use a 3-layer combo rather than relying on one “SEO score”:

My preferred workflow

1. Search Console first — establish actual impact.
Look at indexing, sitemap coverage, crawl/indexing anomalies and Core Web Vitals. Don't blindly fix every warning: prioritize issues affecting important pages or lots of URLs. Google explicitly recommends prioritizing Poor CWV issues by affected URL count/importance. developers.google.comsupport.google.com

2. Crawl the whole site — build the technical inventory.
Use Screaming Frog or Sitebulb with JavaScript rendering enabled if the site is JS-heavy. Export the issues rather than treating the crawler's overall score as gospel.

3. PageSpeed on templates, not every URL.
Test representative pages:

• homepage
• main landing/category template
• product/service page
• blog/article template
• worst-performing important page

Then look for template-level causes: oversized images, render-blocking resources, excessive JS, third-party scripts, poor caching, layout shifts, etc. PSI combines lab diagnostics with real-user data, which makes it useful for distinguishing “technically slow” from “actually hurting users.” developers.google.com

4. Turn findings into a priority matrix.

I'd rank fixes roughly:

P0 — indexing/crawl blockers

• accidental noindex
• robots.txt blocking important content
• canonical pointing somewhere wrong
• important pages returning 4xx/5xx
• redirect chains/loops
• huge crawl traps
• important content inaccessible without JS

P1 — widespread performance problems

• poor CWV on major templates
• enormous page/resource weight
• excessive JS
• slow server response
• image problems affecting hundreds/thousands of URLs

P2 — structural SEO problems

• orphan pages
• duplicate URLs
• bad internal linking
• thin/duplicate templates
• sitemap inconsistencies

P3 — cleanup

• missing metadata
• minor redirects
• low-impact warnings
• cosmetic SEO issues

The key is to join crawl data with Search Console data. A broken canonical on one obscure page isn't equivalent to the same problem across your 40,000 highest-value URLs.

If I inherited the site tomorrow, my minimum stack would be Search Console + Screaming Frog + PageSpeed Insights. If you want the crawler itself to help more with prioritization and reporting, I'd swap Screaming Frog for Sitebulb. sitebulb.com

If you inherited a messy site, I’d use a stack rather than one “SEO audit” tool. The key is separating crawl/indexation problems from real-user performance problems, then using Search Console to validate what Google actually sees.

My preferred combo

1. Screaming Frog SEO Spider — your deep technical crawl

Best for finding the shape of the mess: redirect chains, broken links, duplicate URLs, canonicals, orphan-ish structures, pagination, robots directives, status codes, JavaScript-rendered links, etc. It gives you much more granular control than most cloud audits.

2. Google Search Console — source of truth for Google

Use it alongside the crawler, especially Page Indexing, Crawl Stats, Sitemaps, and Core Web Vitals. A crawler can tell you that something looks wrong; GSC tells you what Google is actually indexing/crawling.

3. PageSpeed Insights + Lighthouse — performance diagnosis

Use this for the performance side rather than treating an SEO tool's “page speed” score as definitive. Look at LCP, INP, CLS, plus the underlying opportunities/diagnostics. Prioritize issues affecting important templates/pages, not every individual URL.

4. Ahrefs Site Audit or Semrush Site Audit — prioritization and monitoring

You don't really need both initially. Both turn a huge pile of technical problems into categorized/prioritized issues. Ahrefs currently checks 170+ technical/on-page issues, including Core Web Vitals, slow pages, indexability, redirects, robots, sitemaps, JS/CSS and links. ahrefs.com Semrush similarly provides severity-ranked issues and thematic reports for crawlability, robots.txt, internal linking, performance and Core Web Vitals. www.semrush.com

The workflow I'd use

Screaming Frog → Search Console → PSI/Lighthouse → Ahrefs/Semrush

Then build one prioritized backlog:

Important: don't blindly fix the tool's highest-count issues first. A single accidental noindex on 10,000 product pages can matter vastly more than 50,000 missing meta descriptions.

If you want the leanest setup, I'd go Screaming Frog + Google Search Console + PageSpeed Insights. Add Ahrefs or Semrush when you need better prioritization, historical monitoring, backlink context, or a team-friendly issue backlog. Ahrefs, for example, explicitly categorizes errors/warnings/notices by importance. ahrefs.com

For a genuinely inherited mess, that three-tool core is enough to find and prioritize most performance + crawlability problems without buying five overlapping SEO suites.

For an inherited “messy” site, I’d avoid relying on one SEO audit score. The best workflow is a stack where each tool answers a different question: Can Google crawl it? Can users load it fast? Which fixes matter most? www.techwench.com

A practical audit stack

ahrefs.com

The order I’d run them

1. Establish the crawl/indexing baseline

• Connect Google Search Console.
• Export:
  • Pages indexed vs excluded
  • Crawl stats
  • Sitemap status
  • “Discovered — currently not indexed”
  • “Crawled — currently not indexed”

2. Crawl the whole site
Run Screaming Frog with:

• JavaScript rendering enabled (if the site is a React/Vue/Angular app)
• Crawl canonicals
• Crawl pagination
• Connect Search Console + Analytics data

Look first for:

• 5xx errors
• 404s with internal links
• redirect chains
• noindex pages receiving traffic
• canonical conflicts
• duplicate URL patterns
• huge numbers of low-value URLs

3. Overlay performance
Don’t chase every PageSpeed warning. Prioritize:

• Templates with thousands of URLs
• Pages getting organic traffic
• Pages failing Core Web Vitals

Typical high-impact fixes:

1. Remove unnecessary JavaScript
2. Optimize oversized images
3. Improve server response time (TTFB)
4. Fix layout shifts from ads/fonts/images
5. Reduce third-party scripts

4. Build a fix priority score

A simple formula:

Priority = SEO impact × affected URLs × ease of fix

Examples:

My “inherited disaster” combo by budget

Free / lean

• Google Search Console
• Screaming Frog free version (up to its crawl limit)
• PageSpeed Insights
• WebPageTest

Small team

• Screaming Frog + Ahrefs or Semrush + Search Console

Enterprise / very large sites

• Screaming Frog or Sitebulb
• Ahrefs/Semrush
• Log file analysis
• Dedicated crawling platforms

The biggest mistake with inherited sites is spending weeks fixing dozens of warnings before finding the few structural problems (bad URL architecture, index bloat, template performance, internal linking failures) that create thousands of issues. lazymetrics.com

If you tell me the site type (WordPress, Shopify, custom app, enterprise CMS) and rough size (hundreds vs millions of URLs), I can suggest a tighter audit sequence.

For a messy inherited site, I’d use a four-tool stack, with each tool answering a different question:

The combo I'd actually run

1. Search Console first → establish what's broken in Google's eyes.
Don't start by fixing every crawler warning. Look at:

• Indexed vs. excluded URLs
• “Crawled — currently not indexed”
• “Discovered — currently not indexed”
• 404/soft-404 patterns
• sitemap coverage
• Core Web Vitals
• Pages receiving impressions but unexpectedly poor clicks

2. Screaming Frog → find the underlying technical causes.
Crawl the site with JavaScript rendering if it's a JS-heavy site. Export the important buckets: status codes, canonicals, robots directives, redirects, internal links, XML sitemap URLs, and page depth. Screaming Frog is particularly useful because you can get down to URL-by-URL evidence rather than relying on an overall “SEO score.” www.techradar.com

3. PageSpeed Insights → prioritize performance separately.
Don't treat the Lighthouse score as your entire performance diagnosis. Pay particular attention to field Core Web Vitals, then use the lab diagnostics to identify causes such as oversized images, excessive JS, render-blocking resources, or slow server response. pagespeedinsights.dev

4. Ahrefs Site Audit → turn the mess into a recurring backlog.
It's useful after the initial forensic crawl because it groups issues, identifies how many URLs are affected, and lets you monitor whether the technical debt is actually shrinking. ahrefs.com

How I'd prioritize the fixes

I'd score findings roughly like this:

P0 — fix immediately

• Important pages blocked by robots.txt/noindex
• Wrong canonicals
• 5xx errors
• Major redirect/indexation problems
• Key pages absent from Google's index
• Severe CWV problems across important templates

P1 — high impact

• Broken internal links
• Large redirect chains
• Bad sitemap URLs
• Huge JS/CSS payloads
• Slow server response
• Important pages buried extremely deep

P2 — cleanup

• Duplicate/missing titles
• Meta descriptions
• Image alt text
• Minor schema issues
• Low-value duplicate URLs

The key is cross-referencing tools rather than blindly following their scores. For example, if Screaming Frog says 20,000 URLs have an issue but Search Console shows only 30 of those URLs matter to Google/search traffic, you probably shouldn't make that your first 20,000-page project.

For a truly chaotic site, my preferred workflow is:

Search Console → Screaming Frog → PageSpeed Insights → Ahrefs → prioritized Jira/Sheets backlog → re-crawl → Search Console validation.

That gives you Google's perspective + raw crawl data + real performance data + ongoing monitoring, without letting any one SEO tool dictate the priorities.

For an inherited, messy site, I’d use a combination rather than one “SEO audit” tool:

1. Google Search Console — start here for indexing, crawl errors, sitemap coverage, Core Web Vitals, and pages Google actually knows about.
2. Screaming Frog SEO Spider — your deep technical crawl: broken links, redirects, canonicals, duplicate/missing metadata, orphan-ish patterns, pagination, hreflang, etc.
3. PageSpeed Insights / Lighthouse — diagnose performance and Core Web Vitals at the page level.
4. Ahrefs or Semrush — layer on backlinks, organic visibility, keyword cannibalization, and competing pages so you can distinguish technical noise from fixes that could actually affect traffic.
5. Chrome DevTools — useful when Lighthouse tells you something is slow but you need to identify the actual JS, CSS, image, or network bottleneck.

The prioritization workflow I'd use

First: crawlability/indexation

• GSC: indexing anomalies and excluded pages
• Screaming Frog: 4xx/5xx, redirect chains, robots directives, canonicals, XML sitemap consistency
• Fix anything preventing important URLs from being crawled/indexed.

Second: performance

• PSI/Lighthouse: LCP, INP, CLS and resource-level diagnostics
• Identify sitewide problems first—bloated JS, render-blocking resources, huge images, poor caching—rather than optimizing individual low-value pages.

Third: SEO impact

• Ahrefs/Semrush + GSC: determine which affected URLs have rankings, impressions, links, or conversions.
• Prioritize fixes that combine high SEO impact × many affected URLs × reasonable implementation effort.

A useful spreadsheet column set is:

Issue → URLs affected → Indexable? → Traffic/impressions → SEO impact → Performance impact → Effort → Priority

If you only want three tools: Search Console + Screaming Frog + PageSpeed Insights. That gives you the strongest foundation for separating “the site is messy” from “this mess is actually hurting Google crawling, indexing, or users.”

For an inherited, messy site, I’d use a stack rather than one SEO crawler:

1. Google Search Console — start here for actual Google crawl/indexing problems: indexing, crawl stats, sitemap issues, Core Web Vitals, and pages Google is excluding.
2. Screaming Frog SEO Spider — your deep technical inventory. Crawl the site and surface broken links, redirect chains, canonical problems, duplicate/near-duplicate pages, orphan-ish patterns, robots directives, pagination, and huge page inventories.
3. PageSpeed Insights + Lighthouse — prioritize performance fixes using field data (when available) plus lab diagnostics. Pay particular attention to LCP, INP, CLS, render-blocking resources, JavaScript, image weight, and caching.
4. Ahrefs or Semrush — useful for putting technical issues in business context: organic traffic, important landing pages, backlinks, rankings, and competing sites. Their site-audit crawlers are useful, but I wouldn't treat their severity scores as gospel.
5. Google Analytics — connect technical problems to actual user/traffic impact. A slow or broken page with meaningful organic traffic should outrank an obscure technical error on a page nobody visits.

How I'd prioritize

Create a simple matrix:

Priority = SEO impact × affected pages × business importance × confidence/ease of fix

Then roughly work in this order:

P0 — blocking

• Important pages accidentally noindex
• Robots.txt blocking critical sections
• Server errors / widespread 5xxs
• Major canonical or redirect mistakes
• Sitemap/indexation failures
• Pages effectively inaccessible to crawlers

P1 — high-impact

• Slow templates affecting lots of organic landing pages
• Poor Core Web Vitals on important URLs
• Large redirect chains
• Broken internal links
• Duplicate/canonicalization problems
• Massive crawl waste from parameters, faceted navigation, or infinite URL variations

P2 — cleanup

• Missing/duplicate titles and descriptions
• Image optimization
• Schema improvements
• Minor heading/metadata inconsistencies
• Low-value duplicate pages

The key is don't blindly fix every warning. A crawler can produce thousands of "issues" that have little SEO consequence. Cross-reference each finding with Search Console + traffic + important URLs/templates before assigning engineering work.

If you tell me roughly what CMS/stack the site uses and its size (e.g. 5k vs. 500k URLs), I can suggest the leanest tool combination and an audit workflow.

For an inherited, messy site, I’d use a stack rather than one SEO crawler:

1. Google Search Console — crawl/indexing reality: indexing issues, sitemap status, Core Web Vitals, manual actions, and pages Google actually knows about.
2. Screaming Frog SEO Spider — technical inventory: broken links, redirects, canonicals, duplicate/missing metadata, orphan-ish patterns, pagination, status codes, and crawl-depth issues.
3. PageSpeed Insights + Lighthouse — performance: LCP, INP, CLS, render-blocking resources, image/script problems, and actionable performance diagnostics.
4. Ahrefs Site Audit or Semrush Site Audit — prioritization layer: groups technical issues, tracks changes, and adds broader SEO context/backlinks.
5. Google Rich Results Test — validate structured data on important templates.

How I'd prioritize the mess

P0 — Can Google crawl/index it?

• 4xx/5xx errors
• accidental noindex
• robots.txt blocking important URLs
• bad canonicals
• redirect chains/loops
• XML sitemap problems
• duplicate URL variants

P1 — Is it wasting crawl budget or creating index bloat?

• faceted/filter URLs
• parameter duplicates
• huge numbers of thin/duplicate pages
• infinite crawl spaces
• orphaned important pages
• excessive redirects

P2 — Is it slow for users?

• poor LCP/INP/CLS
• oversized images
• excessive JavaScript
• render-blocking CSS/JS
• slow server response/TFFB

P3 — Cleanup

• titles/meta descriptions
• headings
• internal linking
• structured data
• image alt text

Best combo for most sites: Search Console + Screaming Frog + PageSpeed Insights. Add Ahrefs or Semrush when you need ongoing monitoring, backlink context, and a more convenient prioritization dashboard.

The important part is not treating the audit's issue count as the priority. Cross-reference crawler findings with Search Console's indexed/traffic data and the business value of the affected URLs. A single broken canonical on 500 important product pages matters much more than 5,000 missing alt attributes.

For a messy inherited site, the best approach is not one SEO crawler—it’s a stack where each tool answers a different question:

1. What’s broken? (technical discovery)
2. What hurts rankings/users most? (prioritization)
3. What should we fix first? (impact vs effort)

A strong combo:

Practical audit workflow

Phase 1 — Crawl the site

Run Screaming Frog or Sitebulb first.

Create buckets:

Critical

• Pages blocked by robots.txt accidentally
• noindex on important pages
• Broken internal links
• 5xx errors
• Wrong canonical tags
• Massive redirect chains

High impact

• Duplicate titles/meta descriptions
• Thin pages
• Orphan pages
• Poor internal linking
• Slow templates

Cleanup

• Old URLs
• Low-value archives
• Minor metadata issues

Phase 2 — Confirm with Google data

In Search Console, compare the crawler findings with reality:

Look at:

• Pages indexed vs submitted
• Excluded pages
• Crawl stats
• Pages losing clicks/impressions
• Core Web Vitals report

A common inherited-site surprise: the crawler finds thousands of “problems,” but only 50 pages matter for search traffic.

Phase 3 — Prioritize fixes with an impact matrix

A simple scoring model:

Priority = (Traffic potential × SEO impact × Confidence) ÷ Effort

Examples:

If I inherited the site tomorrow, my first-week stack would be:

1. Google Search Console — understand Google’s problems
2. Screaming Frog SEO Spider — full crawl inventory
3. Google PageSpeed Insights — performance baseline
4. Sitebulb — easier prioritization/reporting
5. Ahrefs or Semrush — decide which pages are worth saving

One extra step that often pays off: before deleting or consolidating anything, export all existing URLs, rankings, backlinks, and analytics landing pages. Messy inherited sites often contain valuable pages hidden under poor architecture.

If you've inherited a messy website, the biggest challenge usually isn't finding issues—it's figuring out which ones are actually blocking traffic and which can wait. A good stack combines crawler data, performance diagnostics, and search engine data.

A practical combination looks like this:

My recommended workflow

1. Crawl the whole site first

Run Screaming Frog against every URL.

Look for high-impact problems such as:

• Pages blocked by robots.txt accidentally
• noindex pages that should rank
• Broken internal links (404s)
• Redirect chains
• Canonical mistakes
• Duplicate content
• Orphan pages
• Thin pages
• Missing H1/title tags

This gives you a complete inventory before making changes.

2. Compare against Google's view

Open Search Console and compare.

Focus on:

• Pages discovered but not indexed
• Crawled but not indexed
• Soft 404s
• Duplicate without user-selected canonical
• Server errors
• Sitemap issues

These are often more important than issues a crawler finds because Google is telling you exactly what it's struggling with.

3. Measure performance

Don't test every page.

Instead test:

• Homepage
• Top landing pages
• Highest traffic blog post
• Product/category templates
• Search results pages

Use PageSpeed Insights to identify:

• Largest Contentful Paint (LCP)
• Cumulative Layout Shift (CLS)
• Interaction to Next Paint (INP)
• Render-blocking resources
• Image optimization opportunities

Template-level fixes often improve hundreds of pages at once.

4. Find internal linking problems

Screaming Frog is excellent for:

• Click depth
• Pages with few internal links
• Pages receiving no internal PageRank
• Redirected internal links

Deep pages (5–7 clicks from the homepage) are often good candidates for improved internal linking.

5. Prioritize by impact

Instead of fixing thousands of warnings, sort work into tiers.

Tier 1 (highest ROI)

• Pages accidentally blocked from indexing
• Server errors (5xx)
• Broken internal links
• Incorrect canonicals
• Slow page templates
• XML sitemap issues

Tier 2

• Duplicate metadata
• Missing meta descriptions
• Redirect chains
• Large images
• JavaScript rendering bottlenecks

Tier 3

• Minor title tweaks
• Missing alt text (unless accessibility is a priority)
• Small HTML validation issues
• Cosmetic SEO warnings

If you have a budget

A strong professional stack is:

• Google Search Console
• Google Analytics
• Screaming Frog SEO Spider
• Ahrefs

This combination covers crawling, indexing, backlinks, content opportunities, and performance.

If your budget is $0

You can still get a lot done with:

• Google Search Console
• PageSpeed Insights
• Chrome DevTools Lighthouse
• Free version of Screaming Frog SEO Spider (up to 500 URLs)

That setup is enough to identify most major crawlability and performance issues on a small to medium-sized site.

A useful rule when prioritizing fixes is to score each issue by Impact × Scale × Effort. For example, a single template fix that improves Core Web Vitals across 2,000 pages is usually far more valuable than editing 500 individual page titles. Likewise, resolving an indexing problem affecting an entire section of the site should generally come before metadata clean-up. This approach helps you focus on changes that are most likely to improve search visibility and user experience with the least engineering effort.

If you've inherited a messy website, the biggest challenge usually isn't finding issues—it's figuring out which ones actually matter first. A good workflow combines tools that answer different questions:

• Can search engines crawl and index the site?
• Is the site technically healthy?
• Is it fast for users?
• Which problems have the biggest SEO impact?

A practical stack looks like this:

My preferred workflow

1. Start with Google Search Console

Before crawling anything:

• Indexed vs. excluded pages
• Crawl anomalies
• Core Web Vitals
• Manual actions
• Sitemap errors

This tells you where Google is already struggling.

2. Crawl the site with Screaming Frog

This usually uncovers hundreds or thousands of issues.

Focus on:

• 4xx and 5xx pages
• redirect chains
• duplicate titles
• duplicate H1s
• missing canonicals
• noindex mistakes
• orphan pages
• thin pages
• pages over 3–4 clicks deep

Export everything into Excel or Google Sheets.

3. Compare crawl vs. Search Console

This is where priorities become obvious.

Examples:

• Crawled but not indexed → investigate quality or duplication.
• Indexed but not linked internally → improve architecture.
• Broken URLs receiving backlinks → high priority.
• Pages Google can't reach → fix immediately.

4. Measure templates with PageSpeed Insights

Don't test every page.

Instead test representative templates:

• homepage
• category page
• product page
• article
• landing page

If one product template is slow, hundreds of pages may share the same problem.

5. Run a site audit

Ahrefs or Semrush help rank issues by severity.

Ignore "SEO score."

Instead look for:

• internal linking problems
• crawl waste
• duplicate content
• canonical conflicts
• JavaScript rendering issues
• slow templates

6. Prioritize by impact, not issue count

A simple framework is:

For very large websites (10k+ pages)

Add:

• server log analysis
• crawl budget analysis
• JavaScript rendering checks
• XML sitemap validation
• indexation ratio (Indexed ÷ Crawlable pages)

These often reveal issues that page-level audits miss.

A simple 80/20 tool stack

If you only want four tools that cover most technical SEO work:

1. Google Search Console
2. Screaming Frog SEO Spider
3. PageSpeed Insights
4. Ahrefs Site Audit (or Semrush Site Audit)

That combination gives you:

• Google's perspective on indexing and crawling
• a complete technical crawl
• real-world performance data
• prioritized recommendations across the site

It's a strong balance of depth and efficiency for taking over an existing website and deciding what to fix first.

If you've inherited a messy website, the goal isn't to find every issue—it's to identify the small number of fixes that will have the biggest impact on crawling, indexing, and user experience. A combination of complementary tools works much better than relying on a single SEO platform.

Here's a practical stack and what each tool is best at:

My recommended workflow

1. Crawl the entire site first

Run Screaming Frog.

Focus on:

• 404 pages
• redirect chains
• redirect loops
• orphan pages
• duplicate titles
• duplicate H1s
• missing canonicals
• noindex mistakes
• pages deeper than 4–5 clicks
• huge image files
• thin content

This becomes your master inventory.

2. Compare against Google Search Console

Look for mismatches:

• Pages Google can't crawl
• Indexed pages that shouldn't exist
• Important pages not indexed
• Soft 404s
• Server errors
• Sitemap problems

If Search Console and Screaming Frog disagree, investigate why.

3. Audit Core Web Vitals

Use Lighthouse/PageSpeed.

Prioritize:

• LCP
• INP
• CLS

Then identify why:

• oversized images
• too much JavaScript
• render-blocking CSS
• unused CSS
• third-party scripts
• slow server response

4. Examine site architecture

This often reveals the biggest wins.

Questions to answer:

• Are important pages buried?
• Are categories linked well?
• Does internal linking support key pages?
• Are orphan pages valuable?
• Is crawl depth too high?

Sitebulb's visualizations make these issues much easier to spot than spreadsheets.

5. Check crawl budget

This matters especially on larger sites (thousands of URLs).

Look for:

• faceted navigation
• parameter URLs
• duplicate archives
• search pages
• infinite calendars
• session IDs

These can waste crawler resources.

6. Review indexing

Common surprises include:

• indexable staging pages
• duplicate HTTP/HTTPS versions
• duplicate www/non-www versions
• pagination issues
• conflicting canonical tags
• accidental noindex directives

Priority order

I usually rank fixes like this:

High impact

• 5xx server errors
• robots.txt blocking important pages
• noindex on valuable pages
• broken canonical tags
• sitemap issues
• redirect loops
• broken internal links
• pages Google can't crawl

Medium impact

• Core Web Vitals failures
• oversized images
• JavaScript rendering problems
• duplicate metadata
• crawl depth
• weak internal linking

Lower impact

• missing alt text
• title length tweaks
• meta description rewrites
• heading hierarchy cleanup
• minor HTML validation issues

These matter, but they're rarely the first place to invest effort.

If I could only choose four tools

1. Google Search Console — What Google actually sees and indexes.
2. Screaming Frog SEO Spider — The most comprehensive technical crawler for finding structural issues.
3. PageSpeed Insights/Lighthouse — Performance diagnostics tied to Core Web Vitals.
4. Sitebulb — Excellent for visualizing site architecture and explaining technical issues to stakeholders.

That combination covers nearly everything needed to prioritize performance and crawlability improvements. Once you've identified the highest-impact issues, create a backlog that scores each fix by SEO impact × implementation effort (for example, on a 1–5 scale). This helps you tackle quick, high-value improvements before investing time in lower-impact refinements.

For a messy inherited site, the best approach is not one SEO crawler—it’s a stack where each tool answers a different question:

1. What’s broken? (technical audit)
2. What matters most? (impact/prioritization)
3. What is Google actually seeing? (crawl/index reality)
4. What affects users? (performance)

A strong combo:

The workflow I’d use on an inherited site

Phase 1 — Establish reality (day 1)

• Connect Google Search Console.
• Export:
  • indexed pages
  • excluded pages
  • sitemap URLs
  • top landing pages
  • Core Web Vitals issues
• Run a full Screaming Frog crawl.

Phase 2 — Fix “SEO fires” first
Rank issues by:

Impact × confidence × effort

Highest priority:

1. Pages blocked from indexing accidentally
2. Broken important URLs (404/5xx)
3. Wrong canonicals
4. Massive duplicate/thin page problems
5. Slow templates affecting many URLs
6. Bad internal linking
7. Sitemap problems

Usually lower priority:

• Missing meta descriptions
• Minor heading issues
• Small image alt gaps

Phase 3 — Performance
Use PageSpeed Insights on:

• homepage
• top organic landing pages
• biggest templates (product/category/blog/etc.)

Don’t optimize one page only—fix the template causing thousands of slow pages.

Phase 4 — Crawl waste cleanup
Look for:

• millions of parameter URLs
• faceted navigation explosions
• redirect chains
• old CMS-generated pages
• orphan content

A practical “minimum stack” if you want to keep costs down

• Google Search Console (free)
• Screaming Frog (free up to 500 URLs; paid for large sites)
• PageSpeed Insights (free)
• Ahrefs Webmaster Tools (free site audit/backlink data)

If the site is very large (100k+ URLs)

Add:

• server log analysis
• Sitebulb or enterprise crawler
• a backlink tool (Ahrefs/Semrush/Majestic)

One thing that helps a lot with inherited sites: make a spreadsheet of all issues mapped to affected URL count + organic traffic/value, rather than fixing the crawler’s “critical” list blindly. A “critical” issue affecting 2 old pages is often less important than a “warning” affecting 50,000 URLs.