A broken website is an easy lead — the pain is obvious. But broken sites are a small slice of the market. The much larger pool is businesses whose sites look completely fine to a human and are quietly invisible to Google. The pages load, the design is decent, the phone number's there — and yet the site ranks for nothing, because it's leaking search visibility in ways the owner has no way to see.
Those businesses are harder to spot but far more numerous, and the conversation with them is different. You're not telling them their front door is broken. You're telling them they built a store with no sign on the road. To have that conversation credibly, you need more than a surface health check — you need to actually crawl the site and audit what a search engine sees.
"A slow or insecure site is a fire. An invisible site is a slow leak — less urgent, far more common, and worth more over time. The deep audit is how you find the leaks and prove they're real."
Fast scan versus deep audit — two different tools
It's worth being precise about the difference, because they qualify different prospects.
| Fast scan | Deep SEO audit | |
|---|---|---|
| Finds | Broken: insecure, down, slow, compromised. | Invisible: unindexable, unstructured, unfound. |
| Depth | One request per site, seconds each. | A real crawl across many pages. |
| Pitch | "Your site is broken — urgent, technical." | "Your site is fine but Google can't see it — growth." |
| Prospect pool | Small, obvious, warm. | Large, hidden, consultative. |
You run the fast scan across the whole database for triage. You run the deep audit on the sites that passed the fast scan but still aren't ranking — the "looks fine, performs like a ghost" segment. That's the deep audit's job.
What the crawl actually audits
The deep audit is a crawler that walks a site's pages and checks each one against the things a search engine cares about. It's the same engine we use to score sites in bulk. The checks fall into a few buckets.
Indexability — can Google even include this page?
This is the first and most damaging failure, and it's shockingly common. A page can be perfect and still be invisible because something is quietly telling Google to stay out: a stray noindex tag left over from a staging site, a robots.txt rule blocking a whole section, a canonical tag pointing every page at the homepage, a redirect chain that never resolves. The crawler checks every page for these, because a page that can't be indexed can't rank, no matter how good it is. We've found businesses whose entire site was set to noindex from a launch that never got un-launched — invisible for months and no idea why.
Structure — does the page tell Google what it is?
Search engines read structure. The crawler checks for a present, unique, appropriately-sized title tag and meta description on every page; a sane heading hierarchy (one H1 that describes the page, logical H2s beneath it); and whether pages are thin or substantive. A site where every page shares the same generic title, or where the H1 is a logo image with no text, is handing Google nothing to work with.
Schema — is the business machine-readable?
Structured data — the JSON-LD that tells Google "this is a local business, here's the name, address, phone, hours, reviews" — is how you earn rich results and local prominence. Most small-business sites have none. The crawler flags its absence, because adding proper LocalBusiness and Service schema is one of the highest-leverage, most-concrete fixes you can offer a local prospect.
Foundation — sitemap, robots, mobile, speed
The audit rounds out with the fundamentals: is there a valid sitemap and is it actually referenced from robots.txt; is the site genuinely mobile-friendly (not just "responsive" but usable with a thumb); how does it score on core speed metrics. These overlap with the fast scan but go deeper — the fast scan asks "is it up and secure," the audit asks "is it built to be found and to convert."
"Indexability, structure, schema, foundation. Four buckets, dozens of checks, one output: a specific list of reasons this business is invisible — each one fixable, each one provable."
The output: a score plus a fix list
Every audited site gets a score and, more importantly, a list of specific findings — not "your SEO is bad" but "these six pages are set to noindex, none of your pages have meta descriptions, and you have no LocalBusiness schema." That specificity is the entire value. It turns an audit into a conversation where you're the person who noticed something real.
The owner reads that and thinks: this person actually looked at my site and found something specific. That's the opposite of a spray-and-pray pitch, and it's only possible because the crawl did the looking for you, at scale.
Why it’s an engine, not a one-off report
The reason to build this as a reusable crawler rather than auditing sites by hand is leverage. Once the engine exists, it audits a hundred prospects as easily as one. It becomes the scoring layer behind bulk outreach — every prospect gets a search-visibility score, and the low scorers with high business potential rise to the top of the list. The same engine powers client-facing audits later, when a prospect becomes a client and wants the full picture.
So the deep audit does double duty: it qualifies cold prospects by finding provable, specific problems, and it becomes a deliverable the moment someone says yes. You built the tool to find leads; it turns out to also be the thing you hand clients on day one. That's the pattern worth chasing — infrastructure that qualifies prospects on the way in and serves clients on the way through.