ChatGPT answers, unedited

For an inherited “messy” site, I’d avoid relying on one giant SEO suite. The fastest way to get a prioritized fix list is usually a stack where each tool has a specific job: crawl reality, Google reality, performance reality, and business impact. Semrush Zapier

A practical SEO audit stack

Semrush Click Raven## The workflow I’d use on an inherited site

1. Establish the crawl baseline

Run Screaming Frog first.

Export:

• All URLs + status codes
• Indexability
• Canonical tags
• Title/meta issues
• Duplicate content groups
• Internal link counts
• Redirect chains

Immediate red flags:

• 4xx/5xx pages with backlinks
• Thousands of non-indexable URLs
• HTTP pages mixed with HTTPS
• Multiple versions of the same page
• Important pages with few/no internal links

2. Compare against Google Search Console

Look for mismatches:

• Site has 50k URLs, Google indexes 5k → likely crawl/indexation problem
• Google indexes junk URLs → canonical, parameter, or internal linking issue
• Important pages missing from index → inspect rendering, robots rules, internal links, sitemap

3. Audit speed separately

Don’t treat “SEO health score” as performance truth.

Check:

• Largest Contentful Paint (LCP)
• Interaction to Next Paint (INP)
• Cumulative Layout Shift (CLS)
• JavaScript execution
• Image payloads
• Third-party scripts

Prioritize fixes that affect many templates:

• Homepage template
• Product/category templates
• Blog/article templates
• Navigation/footer components

4. Create a fix backlog with impact scoring

I’d score issues like this:

Priority = SEO impact × number of affected URLs × ease of fix

Example:

My “minimum viable” stack

If you want the lean version:

1. Google Search Console (free baseline)
2. Screaming Frog (technical truth)
3. PageSpeed Insights (performance truth)
4. One paid suite (Semrush/Ahrefs) for prioritization and ongoing monitoring

That combination usually reveals 90%+ of the high-value cleanup work without drowning you in thousands of low-impact warnings. Semrush Zapier

If you tell me the site type (WordPress, ecommerce, SaaS, publisher, local business) and approximate size (100 pages vs 100k+), I can suggest a tighter audit sequence and what to ignore.

If you want the lean version:

1. Google Search Console (free baseline)
2. Screaming Frog (technical truth)
3. PageSpeed Insights (performance truth)
4. One paid suite (Semrush/Ahrefs) for prioritization and ongoing monitoring

That combination usually reveals 90%+ of the high-value cleanup work without drowning you in thousands of low-impact warnings.

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

Practical audit stack

Ahrefs Semrush## My recommended order of operations

1. Establish the “damage map”

Run:

1. Google Search Console
2. Screaming Frog crawl
3. PageSpeed/Lighthouse samples

Create a spreadsheet with columns:

• Issue
• URLs affected
• Traffic/value of affected pages
• SEO risk
• Dev effort
• Priority

Don’t fix everything the crawler reports. A site can easily have thousands of low-impact warnings.

2. Fix crawlability before speed

Prioritize:

P0 — blocking search engines

• robots.txt accidentally blocking important sections
• noindex on valuable pages
• broken XML sitemap
• wrong canonical tags
• widespread 4xx/5xx errors
• redirect loops

P1 — wasting crawl budget / confusing architecture

• thousands of duplicate URLs
• faceted navigation creating infinite URL combinations
• orphan pages
• very deep important pages
• bad internal linking

P2 — performance

• oversized images
• unused JavaScript/CSS
• slow server response time
• third-party scripts
• poor caching

3. Use two crawlers if the site is truly chaotic

A good combo:

• Screaming Frog → forensic crawl (“show me every URL and attribute”)
• Semrush/Ahrefs Site Audit → ongoing monitoring (“tell me what broke this week”) Ahrefs Semrush

They will overlap, but the difference is useful: one gives raw evidence, the other helps manage the backlog.

Budget-conscious setup

Free-ish stack

• Google Search Console
• Screaming Frog free tier (for smaller sites)
• Lighthouse/PageSpeed Insights
• Chrome DevTools

Professional cleanup project

• Screaming Frog paid
• Semrush or Ahrefs
• Search Console
• Lighthouse

Enterprise / huge sites

• Add log-file analysis (to compare what Googlebot actually crawls vs. what you think it crawls)
• Consider enterprise crawlers such as Lumar/Botify

A simple prioritization formula

Score each issue:

Priority = SEO impact × number of affected URLs × business importance ÷ implementation effort

Example:

• 5,000 URLs blocked by noindex → emergency
• 300 pages with missing meta descriptions → probably later
• Homepage LCP 8 seconds → high
• 20 old blog posts with duplicate H1s → low

If you tell me the CMS (WordPress, Shopify, custom, etc.), approximate URL count, and whether traffic has dropped, I can suggest a tighter audit workflow and what reports to export first.

For an inherited, messy site, I’d use a 3-tool stack, because no single crawler gives you both a reliable crawl map and real Google/user performance data.

The combo I’d use

1. Google Search Console — ground truth for crawl/indexing

• Check Page Indexing, URL Inspection, robots.txt, sitemaps, and Crawl Stats.
• This tells you what Google actually discovers, crawls, and indexes—not merely what an SEO crawler thinks it can crawl. Google Help Google Help
• Prioritize things like accidental noindex, blocked important URLs, bad canonicals, sitemap discrepancies, and unexpected 4xx/5xx responses.
• Screaming Frog or Ahrefs Site Audit — structural diagnosis

• Crawl the whole site and export the URL-level issues.
• Look specifically for 5xx/4xx errors, redirect chains, orphan pages, canonical problems, robots directives, duplicate URLs, broken internal links, huge pages, and JavaScript/rendering issues.
• Ahrefs Site Audit, for example, groups issues by severity and covers indexability, redirects, robots, sitemaps, JS/CSS, Core Web Vitals, and page weight. Ahrefs Ahrefs
• If you're doing deep technical archaeology, I'd lean Screaming Frog; if you also want ongoing monitoring and broader SEO reporting, Ahrefs is convenient.
• Google PageSpeed Insights — performance reality check

• Use it on representative templates rather than every URL.
• It combines real-user CrUX data with Lighthouse lab testing and reports metrics including LCP, INP, and CLS. Google for Developers
• Test homepage + major page templates + your highest-traffic/problem URLs.

How I'd turn that into a priority queue

Don't fix issues in the order the crawler lists them. I'd make a sheet like:

The key is cross-validation. A crawler finding 10,000 "errors" doesn't mean you have 10,000 problems. For example, Google explicitly notes that not every non-indexed URL should be indexed; duplicates and intentionally excluded URLs can be perfectly legitimate. Google Help

My practical workflow

GSC → crawler → PSI → prioritize → fix → recrawl → validate in GSC.

If budget is tight, I'd start with Google Search Console + Screaming Frog + PageSpeed Insights. That's enough to uncover most of the nasty crawlability/performance problems without buying a giant SEO suite.

If you tell me roughly how big the site is (e.g. 5k vs 500k URLs), CMS/framework, and whether you have a dev team, I can give you a more specific audit stack and a first-week triage checklist.

If you inherited a messy site, I’d avoid relying on one “SEO audit score.” Use a crawl + Google’s own data + performance data combination, then prioritize by impact.

My go-to stack

• screamingfrog.co.uk — crawlability / technical baseline

• Broken links and 4xx/5xxs
• Redirect chains
• Canonicals and noindex
• Robots.txt conflicts
• XML sitemap problems
• Orphan/poorly linked pages
• Crawl depth and internal linking
• Duplicate titles/content
• JavaScript-rendered content

It identifies 300+ issues and can integrate with Search Console and PageSpeed Insights. Screaming Frog Screaming Frog

• Google Search Console — “what Google actually sees”

• Indexing/coverage problems
• Pages excluded from indexing
• Crawl/index anomalies
• Core Web Vitals
• Search performance by URL/query
• URL Inspection for suspicious pages
• pagespeed.web.dev — performance

• Use field/CrUX data to see how real users experience the site.
• Use Lighthouse diagnostics to find likely causes: render-blocking resources, large images, JavaScript, excessive DOM size, slow server response, etc. Screaming Frog
• GA4 (if available) — business impact

• Don't fix a 1,000-page problem merely because a crawler reports it.
• Cross-reference affected URLs with organic traffic, conversions/revenue, and important landing pages.

How I'd prioritize the mess

Create one spreadsheet with:

Issue → affected URLs → organic traffic → conversions → severity → effort → priority

Then tackle roughly in this order:

1. Pages that should rank but aren't indexable

• Accidental noindex
• Robots.txt blocks
• Bad canonicals
• 404/5xx responses
• Redirect mistakes
• Sitemap/indexation mismatches
• Sitewide problems affecting important URLs

• Slow server/TTFB
• Huge JS/CSS payloads
• Poor Core Web Vitals
• Rendering problems
• Mobile issues
• Crawl-budget / architecture problems

• Massive URL duplication
• Faceted-navigation explosions
• Infinite/parameter URLs
• Very deep important pages
• Weak internal linking
• Page-level technical cleanup

• Duplicate/missing titles
• Meta descriptions
• Heading issues
• Image alt text
• Schema
• Low-impact polish

• Don't let 500 missing meta descriptions distract you from 50 important pages returning 404s.

One particularly useful trick: run Screaming Frog with Search Console + PageSpeed Insights data imported, so your crawl contains technical errors, search performance, and performance metrics at the URL level. It can pull Core Web Vitals/CrUX and Lighthouse data at scale. Screaming Frog

And don't blindly accept an audit tool's priority labels. Screaming Frog itself notes that its priorities are guidance rather than definitive recommendations—the business and search context should determine what gets fixed first. Screaming Frog

If I inherited it tomorrow: I'd start with Search Console + Screaming Frog + PageSpeed Insights, then add GA4 to determine which problems actually matter commercially. That's enough to turn a chaotic site into a ranked remediation backlog without buying five overlapping enterprise SEO platforms.

For a messy inherited site, I’d use a stack rather than one “SEO audit” tool, because crawlability, real Google indexing, and performance are different problems.

My preferred combo

1. search.google.com — source of truth for Google

• Indexing/exclusion problems
• Crawl stats
• Sitemap problems
• Core Web Vitals
• URL Inspection for suspicious pages
• Search performance impact
• Screaming Frog / screamingfrog.co.uk — forensic crawl

• Find 4xx/5xxs, redirect chains, canonicals, noindex, robots issues, orphan-ish pages, duplicate titles, crawl depth, internal-link problems, etc.
• Particularly useful when inheriting a site because you can export the affected URLs and hand developers an actionable list.
• It currently checks 300+ SEO issues and can render JavaScript sites. Screaming Frog Screaming Frog
• pagespeed.web.dev — performance

• Use it on representative templates rather than blindly testing every URL.
• Look at field Core Web Vitals first, then Lighthouse diagnostics.
• Prioritize problems affecting major templates: homepage, category/listing, product/article, etc.
• ahrefs.com — prioritization + monitoring

• Good second crawler to validate the Screaming Frog findings.
• Its issues are categorized into errors/warnings/notices and it can show how many URLs each issue affects. Ahrefs Ahrefs
• Particularly useful for turning a giant technical mess into an ongoing remediation queue.

How I'd actually prioritize

Don't simply fix whatever tool labels "critical." Both Screaming Frog and Ahrefs explicitly acknowledge that tool-generated priority needs site-specific context. Screaming Frog Ahrefs

I'd score findings roughly like this:

The killer workflow is:
GSC → Screaming Frog → PageSpeed → Ahrefs → prioritize by traffic/indexability/URL count → fix → recrawl → verify in GSC.

If the site is large (100k+ URLs), JavaScript-heavy, or recently migrated, I'd modify that stack slightly and add log-file analysis. That's often where the really nasty crawl-budget/indexation problems hide.

If you inherited a messy site, I’d avoid relying on one “SEO health score.” Use a small stack where each tool answers a different question.

My recommended combo

This combination is consistent with current technical-audit workflows: Search Console provides first-party indexing/crawl data, while a crawler supplies the site-wide structural picture and PageSpeed handles performance. Semrush ContentForce AI

The order I'd actually use them

1. Search Console first — find Google-facing problems.

Look for:

• Important URLs that aren't indexed
• robots.txt or noindex problems
• Sitemap URLs that aren't being indexed
• Weird spikes in crawl activity/errors
• Core Web Vitals problems
• Pages receiving impressions but having technical/indexing anomalies

Don't blindly fix every warning. Establish which URLs actually matter to the business.

2. Screaming Frog next — map the mess.

Crawl the whole site and export:

• HTTP status codes
• Redirect chains/loops
• Canonical URLs
• Indexability
• robots directives
• Duplicate titles/H1s
• Internal links
• Crawl depth
• Orphan URLs, if you connect Search Console/Analytics data
• XML sitemap URLs

For a small site, its free version covers up to 500 URLs; paid crawling becomes much more useful for larger sites and JavaScript-heavy sites. Semrush HighLevel Playbooks

3. PageSpeed Insights — diagnose performance separately.

Don't let a generic SEO audit convince you that a page is “slow” without diagnosis. Use PSI to distinguish:

• Field data: what real users are experiencing
• Lab data: what Lighthouse observes in the test
• LCP problems
• INP problems
• CLS problems
• oversized images
• excessive JavaScript
• render-blocking resources
• slow server response

That gives your developers actual remediation targets rather than “increase your SEO score.”

4. Add Semrush or Ahrefs for prioritization/monitoring.

If you're already paying for one, use it rather than buying both. Semrush's Site Audit, for example, crawls the site and organizes technical issues by severity while allowing recurring audits. Semrush

I'd choose Semrush if you also want broader SEO/keyword/competitive analysis; Ahrefs if backlink analysis is particularly important.

5. Sitebulb is the luxury upgrade.

If the inherited site has a complicated architecture, Sitebulb is particularly useful because it turns crawl data into visualizations and prioritized “Hints.” That's excellent for figuring out why important pages are buried five clicks deep or poorly internally linked. Semrush

How I'd prioritize the fixes

Don't prioritize by the number of errors. Use:

Business impact × SEO impact × number of affected important URLs × ease of fix

So I'd generally tackle things in this order:

1. Pages being unintentionally blocked from crawling/indexing
2. Important pages returning 4xx/5xx or redirecting incorrectly
3. Canonical/indexation conflicts
4. Broken internal-link architecture / orphaned important pages
5. Massive duplicate/parameter URL problems
6. Very poor Core Web Vitals on high-value pages
7. Slow server response / bloated templates
8. Images, JS, CSS and other performance optimization
9. Lower-impact metadata/content cleanup

One important principle: fix crawl/indexation blockers before spending weeks optimizing page speed. There's little value in making a page 300 ms faster if Google isn't allowed to index it in the first place. ContentForce AI

If you want the leanest stack

For a typical inherited site, I'd start with just:

Google Search Console + Screaming Frog + PageSpeed Insights

Then add Semrush/Ahrefs if you need ongoing monitoring and broader SEO data. That gets you surprisingly far without turning the audit into a tool-shopping exercise. ighenatt.es

Business impact × SEO impact × number of affected important URLs × ease of fix

For a messy inherited site, I’d use a 3-layer stack rather than rely on one “SEO audit” tool:

1. search.google.com — ground truth for Google

• Indexing/Pages report: what Google actually can and can’t index.
• Crawl stats: whether Googlebot is encountering crawl problems.
• Core Web Vitals: real-user LCP, INP, and CLS data, rather than just lab tests. Google Help
• This should determine whether an apparent technical issue is actually affecting Google.
• screamingfrog.co.uk — forensic crawl

• Crawl the whole site and expose redirects, 4xx/5xxs, canonical problems, orphan-ish structures, duplicate URLs, bad internal links, robots directives, XML sitemap inconsistencies, etc.
• Particularly useful when you inherited a site and don't yet trust its architecture.
• sitebulb.com — prioritization layer

• This is the one I'd add if the site is really messy. Sitebulb turns technical findings into prioritized “Hints” ranked Critical/High/Medium/Low and shows how widely each problem affects the site. Sitebulb Support Sitebulb
• It also combines crawlability/indexability analysis with JavaScript rendering and performance auditing. Sitebulb Support Sitebulb Support
• pagespeed.web.dev — performance diagnosis

• Use it after identifying the important templates/pages.
• It helps distinguish real-user performance problems from lab diagnostics. Don't blindly fix every Lighthouse warning.

The workflow I'd use

GSC → crawler → performance → prioritize

• First: GSC — find actual indexing/crawl failures.
• Second: Screaming Frog or Sitebulb — map the technical mess and quantify affected URLs.
• Third: PageSpeed Insights + GSC CWV — investigate performance on important templates.
• Fourth: rank fixes by SEO impact × number/importance of URLs affected × implementation effort.

A practical priority order is usually:

Indexation blockers → crawl traps/waste → 5xx/major 4xx problems → canonical/redirect problems → internal-link architecture → rendering issues → Core Web Vitals/performance → lower-impact on-page cleanup.

The key is not to produce a 200-item SEO checklist. Sitebulb's own guidance makes the useful distinction: a “Critical” issue affecting two non-indexable URLs may matter less than a High/Medium issue affecting thousands of indexable URLs. Sitebulb Support

If I inherited the site tomorrow, my default combo would be Search Console + Screaming Frog + PageSpeed Insights, with Sitebulb replacing Screaming Frog if stakeholder-friendly prioritization/reporting is especially important.

For an inherited “messy” site, I’d avoid relying on a single SEO score. The best approach is a stack where each tool answers a different question, then you merge the findings into a prioritized backlog. Semrush

Recommended audit stack

Ahrefs Internetzone I## The workflow I’d use on a takeover

1. Establish the “damage map” (day 1)

Run:

1. Google Search Console export:

• Pages not indexed
• Excluded pages
• Top declining pages
• Core Web Vitals failures
• Sitemap status
• Screaming Frog crawl:

• Start with default settings
• Crawl the full site if possible
• Export: - 4xx/5xx URLs
• Redirect chains
• Canonical mismatches
• Duplicate metadata
• Pages with no internal links
• Very deep pages (>4–5 clicks)

2. Fix issues by impact, not by tool severity

A good priority formula:

Impact × Search visibility × Ease of fix

Usually the order is:

Tier 1 — Fix immediately

• Accidental noindex
• robots.txt blocking important sections
• Broken XML sitemap
• Important pages returning 404/500
• Redirect loops
• Canonical tags pointing incorrectly
• Pages with terrible Core Web Vitals on money templates

Tier 2 — Big SEO wins

• Duplicate or thin pages
• Poor internal linking
• Orphan pages
• Massive crawl waste (filters, parameters, archive pages)
• Slow templates

Tier 3 — Cleanup

• Missing alt text
• Minor metadata issues
• Small schema warnings
• Low-impact HTML issues

My “minimum viable” stack

If you inherited a normal marketing site:

• Free: Google Search Console + Screaming Frog free + PageSpeed Insights
• Professional: Google Search Console + Screaming Frog paid + Ahrefs or Semrush
• Enterprise / huge ecommerce: Add Sitebulb, Lumar, or log-file analysis tools

Click Raven IghenattOne practical tip: don’t start by fixing 500 warnings. First find the 10 issues that affect the largest number of indexable URLs or the highest-value pages. A messy site often looks overwhelming because tools surface symptoms, not necessarily root causes.

If you inherited a messy site, I’d combine a crawler + Google’s first-party data + a performance lab, rather than trust one “SEO score.”

My go-to stack

1. screamingfrog.co.uk — your deep crawl.

• Find broken links, redirect chains, orphan-ish URL patterns, canonical problems, noindex/robots issues, duplicate titles, thin pages, sitemap discrepancies, etc.
• Especially useful when you need the actual URL-by-URL evidence rather than a generic health score.
• search.google.com — your reality check.

• Look at indexing, crawl stats, sitemap coverage, pages Google actually knows about, and manual/security issues.
• This is crucial because a crawler can tell you what it discovered; GSC tells you what Google is actually doing.
• pagespeed.web.dev — performance diagnosis.

• Use it for Core Web Vitals and page-level performance.
• Don't prioritize purely by Lighthouse score; prioritize pages/templates with poor real-user performance and significant organic/business traffic.
• Ahrefs Site Audit or Semrush Site Audit — optional “second opinion” and prioritization layer.

• ahrefs.com checks 170+ technical/on-page issues, including indexability, redirects, robots, sitemaps, JS/CSS and Core Web Vitals. Ahrefs
• semrush.com groups issues by severity and explicitly ranks what to fix first. Semrush

How I'd prioritize the mess

Don't simply work down the tool's error list. I'd create four buckets:

Then add traffic/conversion impact to each issue. A slow homepage/template affecting 100,000 visits is a dramatically better engineering target than 4,000 slow blog URLs nobody visits.

The particularly useful combo

Screaming Frog → GSC → PageSpeed Insights → Ahrefs/Semrush

Think of them as answering different questions:

• Crawler: What's structurally wrong?
• GSC: What is Google actually crawling/indexing?
• PSI: What's actually slow?
• Ahrefs/Semrush: Can I consolidate all this into a prioritized technical backlog?

For an inherited site, I'd run the crawler before changing anything, export the baseline, then fix the P0s and re-crawl. That gives you a defensible before/after record instead of chasing whatever warning happens to look scariest. Ahrefs Semrush

If you tell me roughly what CMS/framework it uses and whether it's 100, 10k, or 1M+ URLs, I can give you a much tighter audit workflow and exact crawl settings.

For an inherited, messy site, I’d use a small stack with distinct jobs rather than relying on one giant SEO score.

My preferred combo

• search.google.com — your source of truth for indexing/crawl problems. Look at Page Indexing, sitemap coverage, URL Inspection, and Core Web Vitals. This tells you what Google is actually seeing.
• screamingfrog.co.uk — your deep technical crawler. It finds 4xx/5xx errors, redirect chains, blocked URLs, canonicals, noindex directives, orphan/low-depth pages, internal-link problems, and can render JavaScript. Screaming Frog
• pagespeed-insights.com — your performance debugger. Use it on important templates/pages to investigate LCP, CLS, JavaScript, images, render-blocking resources, etc. PageSpeed Insights
• semrush.com (optional) — useful if you want a more automated prioritized backlog and ongoing monitoring. It groups issues around crawlability, performance, Core Web Vitals, HTTPS, internal linking, and more. Semrush Semrush

How I'd prioritize the mess

Don't start by fixing everything the tools flag. I'd score issues roughly like this:

The key combo is GSC + Screaming Frog + PSI. GSC tells you what Google/user data says is wrong, Screaming Frog tells you how the site's architecture and directives are actually wired, and PSI tells you what is making important pages slow.

One particularly useful trick: Screaming Frog can integrate with GSC and PageSpeed Insights, putting search/performance data alongside crawl data for individual URLs. Screaming Frog That makes it much easier to say “fix these 30 pages first” instead of “here are 4,000 SEO warnings.”

If you give me the CMS (WordPress, Shopify, custom, etc.) and approximate site size, I can give you a concrete first-week audit workflow + priority matrix.

For an inherited “messy” site, I’d avoid relying on one SEO suite. The fastest way to get a prioritized fix list is a stack where each tool answers a different question:

1. Can search engines crawl and index it?
2. Which technical problems affect the most URLs?
3. Which performance issues hurt real users?
4. Which fixes are worth doing first?

A practical combo:

1. Google Search Console — “What Google actually sees” (free)

Use this as your source of truth.

Find:

• Indexed vs excluded pages
• Crawl errors
• Sitemap problems
• Manual actions/security issues
• Core Web Vitals problems
• Queries/pages losing traffic

Pair it with everything else because third-party crawlers can find problems, but Search Console tells you what Google is actually experiencing. Semrush

2. Screaming Frog SEO Spider — deep crawl diagnosis

Best for the “what is broken across the site?” phase.

Run a full crawl and export:

• 4xx/5xx URLs
• Redirect chains
• Duplicate titles/meta descriptions
• Missing canonicals
• Noindex conflicts
• Orphan pages
• Internal linking problems
• Huge images
• JavaScript-rendered content issues

This is usually the first tool I’d run on an inherited site because it gives you the raw inventory. Semrush

3. PageSpeed Insights + Lighthouse — performance triage

Use this for templates, not every URL.

Test:

• Homepage
• Main landing pages
• Blog/article template
• Product/service templates
• Checkout/login flows (if relevant)

Prioritize:

• LCP (largest content loading)
• INP (interaction responsiveness)
• CLS (layout shifts)
• Render-blocking scripts
• Image optimization
• Third-party scripts

4. Ahrefs Site Audit or Semrush Site Audit — prioritization layer

These are useful after the crawl because they turn hundreds of technical findings into grouped issues and trends. Ahrefs Site Audit, for example, covers areas like indexability, redirects, internal links, robots/sitemaps, JavaScript, and performance-related issues. Ahrefs Semrush’s Site Audit is useful if you also need keyword tracking, competitor research, and reporting workflows. Semrush

5. Log analyzer (for bigger sites)

If the site has tens of thousands of URLs, add:

• Screaming Frog Log File Analyzer
• Botify
• Lumar

This answers:

• What is Googlebot actually crawling?
• Is crawl budget wasted?
• Are important pages being ignored?

My recommended workflow

Week 1: Build the damage map

1. Connect Google Search Console
2. Crawl with Screaming Frog
3. Run PageSpeed tests on key templates
4. Import findings into a spreadsheet

Create columns:

Fix order I’d usually use

P0 — Fix first

• Accidental noindex
• robots.txt blocking important sections
• broken canonicals
• sitemap/indexation issues
• 5xx errors
• massive redirect problems

P1 — High impact

• Slow templates
• Huge images
• Poor internal linking
• JavaScript rendering issues
• Core Web Vitals failures

P2 — Cleanup

• Duplicate metadata
• Thin pages
• Minor schema issues
• Alt text gaps

For most inherited sites, the sweet spot is:

Google Search Console + Screaming Frog + PageSpeed Insights + (Ahrefs or Semrush)

That combination gives you crawl truth, Google truth, performance data, and a way to prioritize instead of drowning in 500 SEO warnings. Ahrefs Semrush

Google Search Console + Screaming Frog + PageSpeed Insights + (Ahrefs or Semrush)

That combination gives you crawl truth, Google truth, performance data, and a way to prioritize instead of drowning in 500 SEO warnings. Ahrefs Semrush

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

1. search.google.com — ground truth from Google

• Indexing/Coverage problems
• Crawl stats
• Sitemaps
• Core Web Vitals
• Manual actions/security issues

This tells you what Google is actually encountering, rather than what a third-party crawler thinks it might encounter. Ahrefs

2. screamingfrog.co.uk — forensic crawl

• 3xx/4xx/5xx chains
• Canonicals and noindex
• Orphan/poorly linked pages
• Robots.txt and XML sitemap problems
• Internal-link architecture
• Duplicate titles/content
• Raw HTML vs. rendered HTML, especially important for React/Next/Vue sites. Screaming Frog Screaming Frog
• pagespeed.web.dev — performance diagnosis

• Core Web Vitals
• LCP, INP, CLS
• Mobile vs. desktop performance
• Specific opportunities such as image, CSS, JS and rendering problems.

If you want an easier prioritization layer

Add ahrefs.com. It combines crawlability, indexability, redirects, robots/sitemaps, JS, CSS, Core Web Vitals and other technical issues, and categorizes findings as errors, warnings and notices. Ahrefs Ahrefs

So my preferred combo is:

GSC → Screaming Frog → PageSpeed Insights → Ahrefs (optional)

And I’d prioritize fixes roughly like this:

The key is to prioritize by impact, not number of warnings. A single accidental noindex affecting your product template matters vastly more than 500 missing meta descriptions.

If you give me the CMS/framework (WordPress, Shopify, Next.js, etc.) and approximate site size, I can give you a concrete audit workflow and a “fix these first” checklist.

For an inherited, messy site, I’d use a 3-tool combo, with each tool answering a different question:

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

Use this as the source of truth for indexing and real search performance.

Prioritize:

• Pages excluded from indexing unexpectedly
• noindex, robots.txt, canonical, and redirect problems
• Sitemap/indexing mismatches
• Core Web Vitals issues
• Important URLs that Google can't crawl/index

Search Console's URL Inspection and Page Indexing reports give you Google's actual crawl/index perspective, rather than a third-party crawler's approximation. Google Google Help

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

This is my pick for deep technical diagnosis.

Run a crawl and look especially for:

• 4xx/5xx URLs
• Redirect chains/loops
• Orphaned pages
• Canonical conflicts
• Noindex pages linked internally
• Broken internal links
• Duplicate/near-duplicate URLs
• Bad pagination/hreflang
• Huge HTML/CSS/JS
• JavaScript-rendered content problems

Screaming Frog identifies 300+ issues and lets you export the underlying URL-level data, which is useful when turning an ugly audit into a developer backlog. Screaming Frog

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

Don't optimize based on Lighthouse scores alone. Use PSI to distinguish real-user data from lab diagnostics.

Focus on:

• LCP
• INP
• CLS
• Slow templates/page types
• Render-blocking resources
• Oversized images
• Excessive JS
• Server response time

PSI combines real-world Chrome UX data with Lighthouse lab diagnostics, so it's particularly useful for deciding whether a performance problem is widespread or just a lab artifact. Google for Developers

Optional: ahrefs.com — “Help me prioritize and monitor it”

If you have a large site or want a more management-friendly dashboard, Ahrefs is a good fourth layer. Its Site Audit groups issues by severity, covers indexability, redirects, robots, sitemaps, JS/CSS, Core Web Vitals and slow pages, and can monitor changes between crawls. Ahrefs Ahrefs Help Center

How I'd actually prioritize the mess

Don't create a backlog of 500 SEO warnings. Score fixes roughly like this:

Best workflow:
Search Console → Screaming Frog → PageSpeed Insights → backlog → re-crawl → Search Console validation.

If the site is large (100k+ URLs), JavaScript-heavy, or e-commerce, I'd change the stack slightly because crawl-budget and faceted-navigation problems become much more important.

For an inherited “messy” site, I’d avoid relying on one giant SEO score. The best approach is a stack where each tool answers a different question: Can Google crawl it? Can users load it? Which fixes matter most? AlphansoLabs | Ighenatt

Recommended audit stack

1. Crawlability + technical structure: Screaming Frog SEO Spider

Use it for: finding the ugly stuff hiding in the site.

Prioritize:

• 4xx/5xx errors
• redirect chains and loops
• orphan pages
• bad canonicals
• duplicate titles/meta
• missing indexation controls
• thin pages
• broken internal links
• sitemap vs crawl mismatches

For a takeover audit, this is usually the first deep crawl I’d run. AlphansoLabs |

Pair it with:

• Google Search Console — to see what Google actually indexed and where it’s unhappy (coverage issues, crawl stats, Core Web Vitals). Semrush

2. Performance: Google Lighthouse + WebPageTest

Use them for: figuring out why pages are slow.

Look at:

• Largest Contentful Paint (LCP)
• Interaction to Next Paint (INP)
• Cumulative Layout Shift (CLS)
• JavaScript execution cost
• oversized images
• render-blocking resources
• third-party scripts

Don’t just fix the lowest score. Prioritize:

1. Slow templates used by many URLs
2. Pages bringing organic traffic
3. Mobile performance problems

3. SEO prioritization layer: Ahrefs or Semrush

Use it for: deciding what matters commercially.

These help connect technical problems to:

• lost rankings
• valuable keywords
• backlinks
• traffic-driving pages
• competitors

Ahrefs Site Audit, for example, groups technical issues around areas like indexability, redirects, performance, links, robots, sitemaps, and structured data. Ahrefs

4. Architecture visualization: Sitebulb (optional)

Useful when inherited sites have:

• years of migrations
• weird URL structures
• deep click paths
• bad internal linking

It’s good for answering: “Why are important pages buried?”

My practical combo by budget

Lean/free stack

• Google Search Console
• Screaming Frog free version
• Lighthouse
• PageSpeed Insights

Good enough for many small/medium sites. Ighenatt

Professional takeover audit

• Screaming Frog
• Google Search Console
• Ahrefs or Semrush
• Lighthouse/WebPageTest
• Sitebulb

Enterprise / huge sites

Add:

• log file analysis
• enterprise crawlers like Lumar or Botify TechWench | All Things Tech

How I’d prioritize the fixes after crawling

Create a spreadsheet with columns:

A good first pass usually focuses on:

1. Indexation blockers
2. Crawl waste
3. Template-level performance problems
4. Internal linking issues
5. Content cleanup

If you tell me the site size (rough URL count), CMS (WordPress, Shopify, custom, etc.), and whether traffic/rankings are currently down, I can suggest a tighter audit workflow.

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

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

Use it as the source of truth for:

• Indexed vs. excluded URLs
• Crawl/indexing problems
• Sitemap issues
• Core Web Vitals
• Search traffic/ranking impact

It’s especially important because a crawler can tell you that something looks wrong, while Search Console tells you whether Google is actually encountering/indexing it.

2. screamingfrog.co.uk — “What is structurally broken?”

This is my pick for the deep technical crawl. It can crawl the site and expose 404s, server errors, redirect chains, canonicals, orphan-ish URL patterns, duplicate metadata, crawl depth, internal links, and hundreds of other issues. The free version handles up to 500 URLs. Screaming Frog

For a messy inherited site, this is where I'd start building the fix list.

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

Use this on:

• High-traffic landing pages
• Templates affecting lots of URLs
• Pages with poor Core Web Vitals
• Representative mobile pages

Don't blindly chase a 100/100 Lighthouse score. Prioritize real-user Core Web Vitals and issues that affect important templates.

Optional: ahrefs.com — “Help me turn the mess into a prioritized backlog”

If you have budget, Ahrefs is useful as the ongoing monitoring/prioritization layer. Its Site Audit currently checks 170+ technical/on-page issues, categorizes them by severity, and can incorporate PageSpeed Insights metrics. Ahrefs Ahrefs Help Center

The combo I'd actually use

Search Console + Screaming Frog + PageSpeed Insights

Then, if the site is large or you're responsible for ongoing SEO:

Search Console + Screaming Frog + PageSpeed Insights + Ahrefs

And I'd prioritize fixes roughly like this:

1. Indexation blockers — accidental noindex, bad canonicals, robots.txt blocks, sitemap problems.
2. Server/status problems — 5xx errors, widespread 4xxs, redirect chains/loops.
3. Crawl waste — huge parameter spaces, duplicate URLs, infinite faceted navigation, unnecessarily deep architecture.
4. Internal-link architecture — important pages buried deep or poorly linked.
5. Template-level performance — slow JS/CSS, huge images, poor LCP/INP/CLS.
6. Page-level cleanup — duplicate titles, missing metadata, thin/duplicate pages, etc.

Key principle: don't prioritize by “number of errors.” Prioritize by SEO impact × number of affected important URLs × implementation effort.

For example, fixing one bad JavaScript-heavy template affecting 20,000 URLs can be dramatically more valuable than fixing 500 individual title-tag warnings.

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

1. What is broken?
2. How severe is it?
3. What should we fix first?
4. Did the fixes actually help?

A strong combo:

Semrush Ahrefs## The audit sequence I’d use

1. Start with Google Search Console (baseline)

Export:

• Indexed pages
• Excluded pages
• Not indexed reasons
• Sitemap status
• Core Web Vitals report
• Top pages losing clicks/impressions

This tells you what Google is already struggling with.

2. Run a full crawl with Screaming Frog

Configure it to crawl like Google:

• JavaScript rendering enabled (if the site is JS-heavy)
• Crawl all internal links
• Include XML sitemap URLs

Prioritize findings:

Critical

• Pages blocked by robots.txt accidentally
• Important pages marked noindex
• 5xx server errors
• Broken canonicals
• Bad redirects
• Massive duplicate URL generation

High impact

• Orphan pages
• Very deep pages (many clicks from homepage)
• Missing internal links
• Duplicate titles/H1s
• Thin pages competing with each other

Later

• Minor metadata cleanup
• Small image issues
• Cosmetic HTML problems

3. Run performance checks on templates, not every URL

Pick:

• Homepage
• Main landing pages
• Product/service pages
• Blog/article template

Look for:

• Oversized images
• Too much JavaScript
• Render-blocking CSS
• Slow server response
• Third-party scripts

4. Add a ranking/backlink layer

A crawler can tell you “this page is broken,” but not always “this page matters.”

Use Ahrefs/Semrush to answer:

• Which broken pages had backlinks?
• Which pages dropped traffic?
• Which technical fixes affect revenue pages?
• Which pages are worth saving vs deleting?

If I inherited the site tomorrow, my minimum stack would be:

Free/cheap stack

• Google Search Console
• Screaming Frog free version (small sites)
• PageSpeed Insights
• Google Analytics 4

Professional stack

• Screaming Frog
• Google Search Console
• PageSpeed Insights
• Ahrefs or Semrush
• Sitebulb for reporting

The biggest mistake on inherited sites is fixing hundreds of low-value warnings before finding the 5–10 issues that are actually blocking crawling, indexing, or speed. Build the priority list around traffic/value × SEO impact × implementation effort.

For an inherited “messy” site, I’d avoid relying on a single SEO audit score. The best workflow is a stack where each tool answers a different question: What is broken? How bad is it? How many pages are affected? What should we fix first? Semrush

A strong combo:

1. Crawl + technical inventory: Screaming Frog SEO Spider

Use for: finding the actual mess.

Run a full crawl and export:

• 4xx/5xx errors
• redirect chains and loops
• orphan pages (paired with sitemap/analytics data)
• duplicate titles/meta descriptions
• missing canonicals
• noindex mistakes
• thin pages
• broken internal links
• URL architecture problems
• JavaScript rendering issues

This is usually the “source of truth” for technical cleanup because you can inspect every affected URL rather than just getting a health score. Semrush

2. Google’s own view: Google Search Console

Use for: “What is Google actually doing?”

Prioritize:

• Pages excluded from indexing
• Crawled-but-not-indexed URLs
• Duplicate/canonical conflicts
• Crawl stats
• Manual actions/security issues
• Core Web Vitals field data

This catches problems that crawlers can miss because it reflects Google’s systems and your real search performance.

3. Performance: PageSpeed Insights + Lighthouse

Use for: knowing which speed fixes matter.

Look at:

• LCP (loading performance)
• INP (interaction responsiveness)
• CLS (layout shifts)
• render-blocking resources
• oversized images
• unused JavaScript/CSS
• caching/compression issues

Don’t chase every Lighthouse warning. Tie fixes to templates and high-value pages.

4. Prioritization layer: Semrush Site Audit or Ahrefs Site Audit

Use for: turning 500 warnings into a roadmap.

Helpful for:

• severity scoring
• trend tracking after fixes
• linking technical issues with rankings/backlinks
• reporting to stakeholders

All-in-one platforms are useful because they combine technical findings with broader SEO context, but I wouldn’t use them alone for a deep inherited-site forensic crawl. CBOOMARANK Rankable

5. Optional for big/complex sites: log analysis

If it’s a large site (100k+ URLs), add:

• server logs
• crawl budget analysis
• bot behavior analysis

Tools like enterprise crawlers/log platforms become more valuable when you need to see where Googlebot actually spends time. RankUp

My default audit stack

Small/medium site

• Screaming Frog
• Google Search Console
• PageSpeed Insights
• Semrush/Ahrefs (choose one)

Large ecommerce / marketplace / CMS-heavy site

• Screaming Frog
• Google Search Console
• PageSpeed Insights
• Semrush or Ahrefs
• log analysis

How I’d prioritize fixes after the crawl

Create buckets:

P0 — Fix immediately

• robots.txt blocking important sections
• accidental noindex
• broken canonicals
• major crawl traps
• 5xx errors
• migration leftovers

P1 — High ROI

• slow templates
• duplicate URL problems
• internal linking gaps
• index bloat
• missing sitemap hygiene

P2 — Optimization

• metadata cleanup
• schema improvements
• content consolidation
• minor accessibility/performance tweaks

A common mistake with inherited sites is fixing hundreds of low-impact warnings before resolving a handful of indexing or rendering issues that affect thousands of URLs. Rankable

If you tell me the CMS (WordPress, Shopify, React/Next.js, custom, etc.) and approximate size (pages/URLs), I can suggest a tighter audit workflow and what exports to pull first.

For a messy inherited site, I’d use a three-layer stack rather than rely on one “SEO score.”

My go-to combo

1. search.google.com — reality check

• Find actual indexing/crawling problems Google is encountering.
• Check Pages/Indexing, Core Web Vitals, sitemaps, and URL Inspection.
• This should be your source of truth for “Is Google actually having trouble?”
• screamingfrog.co.uk — deep crawl

• Crawl the whole site and expose 3xx/4xx/5xx chains, canonicals, noindex directives, orphan-ish URLs, duplicate metadata, internal links, pagination, robots directives, etc.
• Particularly useful on inherited sites because you can export the raw URL-level data and work through it systematically. It checks 300+ SEO issues and has JavaScript rendering for JS-heavy sites. Screaming Frog Screaming Frog
• Free up to 500 URLs. Screaming Frog
• pagespeed.web.dev — performance

• Use this for Core Web Vitals and actual performance diagnostics, not just a Lighthouse score.
• Sample your important templates/pages: homepage, category/listing, product/service page, blog/article, etc.
• Look especially at LCP, INP, CLS, render-blocking resources, JS, images, and server response time.
• ahrefs.com — prioritization/monitoring

• Great as the management layer over the crawl data.
• It currently checks 170+ technical/on-page issues, including indexability, redirects, robots.txt, sitemaps, JS/CSS, slow pages and Core Web Vitals. Ahrefs
• Its Errors → Warnings → Notices hierarchy gives you a convenient first-pass priority system, although you shouldn't blindly accept the severity labels. Ahrefs

How I'd prioritize the mess

Don't start by fixing every warning. Build a backlog roughly like this:

The key is to cross-reference tools instead of treating their issue counts as priorities. For example, a sitewide “missing meta description” affecting 20,000 pages is usually less urgent than 50 valuable URLs accidentally carrying noindex.

If I inherited it tomorrow

I'd do:

GSC → Screaming Frog crawl → PageSpeed sample → consolidate into a prioritized backlog → fix P0/P1 → recrawl → verify in GSC → repeat.

If you already pay for Ahrefs, I'd add Ahrefs Site Audit as the ongoing dashboard/monitoring layer. If budget is tight, GSC + Screaming Frog + PageSpeed Insights is a very strong starting stack. Ahrefs also currently offers a free verified-site audit with 5,000 crawl credits/month. Ahrefs Ahrefs

The biggest mistake with inherited sites is optimizing the score rather than fixing the things that prevent Google from discovering, rendering, indexing, or efficiently serving the pages that matter.

If you inherited a messy site, I’d use a 3-layer stack rather than trust any single SEO audit score:

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

Use it as the source of truth for:

• Indexing problems and excluded URLs
• Crawl/indexing anomalies
• Sitemap coverage
• Core Web Vitals
• Search performance and pages/queries losing traffic

2. Screaming Frog — “What is actually on the site?”

screamingfrog.co.uk is my pick for the deep technical crawl. It can expose:

• 4xx/5xx errors
• Redirect chains/loops
• Canonical and noindex problems
• Robots.txt blocks
• Orphan/poorly linked pages
• Duplicate titles/content
• JavaScript-rendered content
• Site architecture and internal-link problems

It also integrates with GSC and PageSpeed Insights, which makes it particularly useful for an inherited site. Screaming Frog

3. Ahrefs Site Audit — “Which problems should I tackle first?”

ahrefs.com is excellent for turning a giant crawl into an actionable backlog. It currently checks 170+ technical/on-page issues, including indexability, redirects, robots, sitemaps, JavaScript, CSS, Core Web Vitals and slow pages. Ahrefs

Its Errors → Warnings → Notices organization gives you a useful first-pass prioritization, although you should override the tool's priorities based on the site's actual traffic and business value. Ahrefs

The combo I'd actually use

For performance, don't chase Lighthouse scores indiscriminately. Look first at pages with poor real-user Core Web Vitals + meaningful organic traffic/conversions, then use PSI/Lighthouse to diagnose why they're slow.

For crawlability, I'd prioritize roughly:

1. Important pages accidentally noindex/blocked
2. 5xx errors and major 4xx problems
3. Broken/incorrect canonicals
4. Redirect chains and large redirect waste
5. Bad XML sitemap URLs
6. Orphaned/high-value pages
7. Massive duplicate/parameter URL generation
8. JavaScript-dependent content Google can't reliably access
9. Internal-link architecture
10. Lower-impact metadata cleanup

Key point: don't let an audit tool convince you that fixing 2,000 missing meta descriptions is more important than fixing 20,000 URLs accidentally excluded from crawling.

If you tell me roughly how big the site is (e.g. 500, 50k, or 5M URLs) and whether it's WordPress/e-commerce/custom, I can give you a concrete audit workflow and prioritization matrix.

For performance, don't chase Lighthouse scores indiscriminately. Look first at pages with poor real-user Core Web Vitals + meaningful organic traffic/conversions, then use PSI/Lighthouse to diagnose why they're slow.

For crawlability, I'd prioritize roughly:

1. Important pages accidentally noindex/blocked
2. 5xx errors and major 4xx problems
3. Broken/incorrect canonicals
4. Redirect chains and large redirect waste
5. Bad XML sitemap URLs
6. Orphaned/high-value pages
7. Massive duplicate/parameter URL generation
8. JavaScript-dependent content Google can't reliably access
9. Internal-link architecture
10. Lower-impact metadata cleanup

Key point: don't let an audit tool convince you that fixing 2,000 missing meta descriptions is more important than fixing 20,000 URLs accidentally excluded from crawling.

If you tell me roughly how big the site is (e.g. 500, 50k, or 5M URLs) and whether it's WordPress/e-commerce/custom, I can give you a concrete audit workflow and prioritization matrix.

If you inherited a messy site, I’d use a small stack with different jobs, rather than trying to make one SEO crawler your source of truth.

My preferred combo

1. search.google.com — reality check

• Indexing status and exclusions
• Sitemap coverage
• Crawl/indexing problems Google actually encounters
• Core Web Vitals from real users
• Search performance, so you can prioritize pages that actually matter
• screamingfrog.co.uk — deep crawl

• Broken links/status codes
• Redirect chains and loops
• Canonicals, noindex, robots directives
• Orphan/poorly linked pages
• Duplicate titles/content
• XML sitemap problems
• Huge pages, slow response times, bloated resources
• JavaScript rendering to compare raw HTML with the rendered DOM, which is particularly useful on React/Vue/Angular sites. Screaming Frog Screaming Frog
• pagespeed.web.dev — performance

• Core Web Vitals
• Lighthouse diagnostics
• Lab vs. real-user performance
• Specific opportunities around JS, CSS, images, caching, etc.
• ahrefs.com — prioritization + ongoing monitoring

• Good second crawler for validating the Screaming Frog findings
• Groups issues into errors/warnings/notices and shows affected URLs
• Covers indexability, redirects, robots, sitemaps, JS/CSS, Core Web Vitals, slow pages, etc. Ahrefs
• It can also incorporate PageSpeed Insights data, which makes performance issues easier to correlate with the crawl. Ahrefs Help Center

How I'd actually prioritize the mess

Don't fix issues in the order the crawler presents them. Build a severity × impact matrix:

The key is to cross-reference the crawl with GSC performance. A problem affecting 500 URLs sounds scary, but if those URLs get no traffic and aren't strategically important, it may be less urgent than a performance problem on your 20 highest-value landing pages.

If you want the leanest stack

I'd start with:

GSC + Screaming Frog + PageSpeed Insights

Then add Ahrefs if you want automated monitoring, backlink/context data, and another independent crawl. Ahrefs currently offers a free Site Audit tier with 5,000 crawl credits/month for verified projects. Ahrefs Help Center

For a particularly ugly inherited site, Screaming Frog + GSC is the combination I'd trust most for the initial forensic audit: crawl the entire site, export the findings, then use GSC to determine which problems actually intersect with Google's indexing and your valuable pages.

If you inherited a messy site, I’d use a 3-layer combo rather than relying on one “SEO audit” score.

My recommended stack

• search.google.com — source of truth for Google

• Find URLs Google actually knows about but isn't indexing.
• Check robots.txt blocks, indexing exclusions, crawl issues, and Core Web Vitals.
• Especially important because a crawler can tell you that something looks wrong, while GSC tells you what Google is actually encountering. Google Help Google Help
• screamingfrog.co.uk — forensic crawl

• Crawl the site yourself and expose the structural mess: 4xx/5xxs, redirect chains, canonicals, orphan-ish pages, duplicate titles, bad internal links, huge pages, etc.
• This is the tool I'd use to understand what is broken and where.
• ahrefs.com — prioritization + monitoring

• Good for turning a huge crawl into categorized issues and tracking whether things improve.
• Its current Site Audit covers 170+ technical/on-page issues, including indexability, redirects, robots, sitemaps, JS/CSS, slow pages and Core Web Vitals. Ahrefs Ahrefs
• It can also run recurring/always-on audits, which is useful once you've inherited the site and started making changes. Ahrefs Help Center
• pagespeed.web.dev + Lighthouse — performance diagnosis

• Use these after the crawl identifies the important/problematic templates.
• Don't obsess over the Lighthouse score itself. Prioritize real-user Core Web Vitals and repeat problems across templates. GSC's CWV report is particularly useful for seeing issues affecting groups of URLs. Google Help

How I'd actually prioritize

I'd build a simple backlog like this:

The key is impact × scale × fixability, not the number of warnings a tool produces.

For example, fixing one bad canonical affecting 20,000 product URLs is vastly more valuable than fixing 200 individually missing meta descriptions.

If you want the leanest setup

Free/cheap:
GSC + Screaming Frog + PageSpeed Insights

Serious inherited-site cleanup:
GSC + Screaming Frog + Ahrefs Site Audit + PageSpeed Insights

And I'd run the process in this order:

GSC → crawl → group issues by template → validate performance → prioritize fixes → recrawl → validate in GSC.

That prevents the classic mistake of spending two weeks fixing low-value SEO warnings while the site's robots.txt, canonicals, redirects, or rendering are fundamentally broken.

For an inherited “messy” site, I’d avoid relying on one SEO audit platform. The best results usually come from combining:

1. A crawler → find technical problems
2. Google’s own data → confirm what actually hurts search visibility
3. A performance tool → diagnose speed bottlenecks
4. A prioritization layer → decide what engineering should fix first

A strong stack:

Semrush Ighenatt## My preferred audit workflow

1. Establish “what’s broken”

Run:

• Google Search Console export: - Pages indexed vs excluded
• Crawl stats
• Core Web Vitals
• Top declining pages
• Screaming Frog crawl: - 3xx/4xx/5xx URLs
• noindex pages
• canonical mismatches
• duplicate titles/descriptions
• deep pages (>3–4 clicks from homepage)
• wasted crawl paths (filters, parameters, old URLs)

2. Separate noise from blockers

Prioritize fixes roughly like this:

P0 — Fix immediately

• Important pages blocked by robots.txt/noindex
• Server errors (5xx)
• Massive redirect chains
• Wrong canonicals
• Broken sitemap/indexation issues

P1 — High impact

• Slow templates affecting many URLs
• Poor internal linking
• Duplicate/near-duplicate pages
• JavaScript rendering problems
• Large image/CSS/JS payloads

P2 — Cleanup

• Missing metadata
• Minor schema warnings
• Low-value thin pages
• Cosmetic HTML issues

3. Add performance investigation

For speed problems, pair:

• PageSpeed Insights → “what Google measures”
• Lighthouse → technical diagnostics
• WebPageTest → waterfall analysis (server response time, third-party scripts, render blocking)

Don’t chase a perfect score; look for fixes that affect thousands of pages:

• shared templates
• CMS plugins
• image handling
• JavaScript bundles
• hosting/CDN configuration

Budget-friendly stack

For a small-to-medium site:

• Google Search Console (free)
• Screaming Frog free tier (or paid if >500 URLs)
• PageSpeed Insights
• Ahrefs Webmaster Tools / similar free diagnostics

Cloudways## Agency/large-site stack

For a large inherited site or migration:

• Screaming Frog for forensic crawling
• Sitebulb for explaining issues to stakeholders
• Semrush or Ahrefs for search impact
• Search Console for Google-side validation
• Log file analysis if crawl budget is a concern

netpartners.marketingOne practical tip: export everything into a spreadsheet with columns for issue → affected URLs → traffic/value → effort → priority. The audit tool will usually give you 500 problems; your job is finding the 10 that matter.

If you inherited a messy site, I’d use a three-layer stack rather than relying on one “SEO audit” score:

1. Crawlability: Screaming Frog + Google Search Console

• screamingfrog.co.uk — your site-wide diagnostic. Crawl the site to find 4xx/5xx errors, redirect chains, orphan/poorly linked pages, canonical problems, robots/noindex conflicts, duplicate URLs, excessive crawl depth, and XML sitemap issues. It can also connect to Search Console and PageSpeed Insights, which makes it especially useful for prioritization. Screaming Frog Screaming Frog
• search.google.com — your Google's-eye view. Check Page Indexing, URL Inspection, sitemaps, crawl/indexing problems, and Core Web Vitals. Search Console tells you what Google actually discovered/indexed rather than merely what a crawler thinks it should do. Google Google Help

2. Performance: PageSpeed Insights + Search Console

• pagespeed.web.dev — use it to diagnose individual templates/pages. It combines lab diagnostics with real-user CrUX data, so don't treat the Lighthouse score itself as the goal. PageSpeed Insights Google for Developers
• Search Console's Core Web Vitals report gives you the real-world picture across URL groups. Focus on LCP, INP, and CLS, particularly pages marked Poor rather than obsessing over a single test URL. Google for Developers Google Help

3. Prioritization: Ahrefs or Semrush

I'd add one of these if the site is large or commercially important:

• Ahrefs Site Audit — good for combining technical issues with organic traffic/backlink context.
• Semrush Site Audit — similarly useful for turning a huge technical issue inventory into something you can sort and work through.

The key is not to blindly fix everything the tools flag. A 1,000-page site can generate thousands of technically valid warnings that have almost zero business impact.

The combo I'd actually use

Screaming Frog → Search Console → PageSpeed Insights → Ahrefs/Semrush

Then build a priority queue roughly like this:

One particularly effective trick: crawl with Screaming Frog while integrating GSC + PSI data. You can then see things like “this URL has a crawl/indexation problem AND gets 2,000 organic visits/month AND has poor LCP.” That's vastly more useful than a generic “87 SEO errors” report. Screaming Frog explicitly supports GSC and PSI integrations for this workflow. Screaming Frog

If the inherited site is React/Next.js/Vue or otherwise heavily JavaScript-rendered, I'd put extra emphasis on Screaming Frog's rendered crawl and comparing raw HTML vs rendered HTML—JS sites can look perfectly fine in a browser while exposing a very different crawlable/indexable page to search engines. Screaming Frog

If you inherited a messy site, I’d use a three-tool stack rather than trying to make one SEO platform do everything:

1. Screaming Frog — find the crawlability problems

screamingfrog.co.uk

Make this your site-wide technical inventory. It can crawl the site and surface broken links, 4xx/5xx errors, redirect chains, canonicals, noindex/robots directives, duplicate pages, XML sitemap issues, internal-link structure, and JavaScript-rendered content. It can also connect to Search Console and PageSpeed Insights. Screaming Frog Screaming Frog

Prioritize from it:

• Pages accidentally blocked/noindexed
• 5xx errors and important 404s
• Redirect chains/loops
• Canonical conflicts
• Orphan/poorly internally linked important pages
• Crawl traps and huge URL sets
• JS-dependent content Google can't discover

2. Google Search Console — establish what Google actually sees

search.google.com

This is the reality check against your crawler. Search Console gives you Google's indexing/crawl information, URL Inspection, sitemap status, crawl/index problems, search performance, and Core Web Vitals. Google Google Help

This is where I'd prioritize business impact. For example, a thousand low-value warnings in Screaming Frog matter less than 20 high-value pages that Google isn't indexing.

3. PageSpeed Insights — diagnose performance

pagespeed.web.dev

Use it for representative templates rather than obsessively chasing a perfect score on every URL. PSI combines Lighthouse lab diagnostics with real-user/field performance data, while Search Console's Core Web Vitals report gives you the site-level picture. Google for Developers Google for Developers

Focus on LCP, INP, and CLS rather than the overall Lighthouse score. Google's current good targets are LCP ≤2.5s, INP <200ms, and CLS <0.1. Google for Developers

The prioritization workflow I'd use

Think of the tools as:

Screaming Frog → "What's technically broken?"
Search Console → "What is Google actually having trouble with?"
PageSpeed Insights → "Which performance problems are users actually experiencing?"

Then rank fixes roughly like this:

One important rule: don't prioritize based on the number of warnings. Prioritize based on affected URL importance × severity × scale. A single noindex on your revenue-driving category page outranks 5,000 slightly-too-long meta descriptions.

For a genuinely chaotic inherited site, I'd start with Screaming Frog + Search Console, build the issue inventory, then use PageSpeed Insights on the major templates. That gives you a much cleaner remediation backlog than relying on an all-in-one SEO score.

For an inherited “messy” site, I’d avoid relying on a single SEO score. The best setup is a crawler + Google data + performance profiler + prioritization layer. A good combo:

1. Crawlability & technical structure (find the mess)

Primary crawler:

• Screaming Frog — best for deep technical crawling: broken links, redirect chains, canonicals, indexability, duplicate pages, JavaScript rendering issues, XML sitemap problems, and custom extractions. HighLevel Playbooks Teksyte
• Alternative: Sitebulb — easier-to-read reports and stronger issue prioritization/visualizations if you need to explain fixes to stakeholders. Sitebulb

Run first and export:

• 4xx/5xx URLs
• redirect chains/loops
• orphan pages
• pages blocked by robots/noindex
• duplicate titles/meta/canonicals
• crawl depth
• internal link gaps
• thin or near-duplicate templates

2. Google’s view of the site (ground truth)

Use:

• search.google.com

Focus on:

• Pages excluded from indexing
• Crawl stats
• Sitemaps
• Core Web Vitals
• Pages losing impressions/clicks

A crawler tells you what could be wrong; Search Console tells you what Google is actually seeing. Semrush

3. Performance diagnosis

Use:

• pagespeed.web.dev
• webpagetest.org

Prioritize:

1. LCP problems (slow main content)
2. INP problems (interaction delays)
3. CLS issues (layout shifts)
4. oversized images
5. render-blocking CSS/JS
6. excessive third-party scripts

4. Prioritization / “what should we fix first?”

Add one SEO suite:

• Semrush — useful for ongoing site health, rankings, competitors, and automated technical issue tracking. Semrush
• Ahrefs — stronger if the inherited site has backlink/history issues or you need to understand lost authority. HighLevel Playbooks

My recommended stack by situation

Small/medium site (<50k URLs)

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

Large site / ecommerce / many templates

• Screaming Frog (deep crawl)
• Sitebulb (prioritized reporting)
• Google Search Console
• PageSpeed Insights
• Semrush/Ahrefs
• Server log analysis if crawl waste is suspected

How I’d triage the first 2 weeks

1. Day 1–2: Crawl the site and create buckets:

• indexing blockers
• performance blockers
• architecture issues
• content/template issues
• Day 3–5: Cross-reference with Search Console:

• Which broken areas actually affect impressions/clicks?
• Week 2: Fix highest-impact items:

• accidental noindex
• bad canonicals
• redirect disasters
• sitemap issues
• slow templates
• internal linking problems

A useful rule: don’t chase 500 warnings. Look for issues affecting many URLs × valuable URLs × Google visibility. That combination usually reveals the real backlog.

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.