repolog.io

An SEO audit is a structured pass over your site that checks whether search engines can crawl, understand, and rank your pages — and it usually bundles in performance, accessibility, and security checks that affect how your site is experienced and trusted. You run one when you want a prioritized list of fixes rather than a vague sense that "SEO needs work." The catch: an audit tells you what's broken, not what to write or who should link to you.

The categories a scan typically covers

A modern audit isn't just meta tags. Tools like Repolog run 60+ checks in a single headless-browser load, grouped into five areas:

If your goal is only classic Google rankings, the first two rows carry the most weight. The last row matters if you want visibility in AI-generated answers, which is a separate channel with separate rules.

How a scan actually runs

The mechanics are simpler than the output suggests:

1. Add your site — enter a domain or import sites you already manage. No install, no code changes, no SDK.
2. Run the scan — a real headless browser loads your page and the checks execute against that live render. This is why performance and accessibility results reflect what a browser actually sees, not just raw HTML.
3. Read the ranked report — every issue comes with its fix, ordered by impact. A full report typically arrives in about a minute.

The key detail is "live browser load." Checks that run against static HTML miss JavaScript-injected content, layout shifts, and focus-order problems. A headless render catches them.

How to read the results and prioritize

Don't work top-to-bottom through the list. Sort by what blocks indexing or ranking first:

• Crawl/index blockers — robots.txt rules blocking the wrong bots, canonical URLs pointing to the wrong page, noindex tags. Fix these before anything else; nothing downstream matters if the page can't be indexed.
• Core Web Vitals failures — LCP and CLS problems on your highest-traffic templates. Fix the template, not individual pages.
• On-page gaps — missing or duplicate titles, broken heading hierarchy, missing alt text. Fast to fix, moderate ranking impact.
• Security and accessibility — exposed config files and contrast failures. Lower direct ranking impact but real trust and usability costs.
• AI readiness — only worth prioritizing if AI search visibility is a goal for you.

A ranked report does this ordering for you, but you should still sanity-check it against your own traffic data. A "critical" issue on a page nobody visits is less urgent than a "warning" on your top landing page.

One-time audit vs. ongoing monitoring

A single audit is a snapshot. Sites change — you publish, redesign, add scripts, change headers. Two things make an audit useful over time:

• Keyword tracking tied to pages — map each target keyword to the page that should rank for it, then re-scan to grade that page against its keyword. This turns a static report into a feedback loop.
• Search Console integration — surfaces queries you already get impressions for and flags keywords cannibalized across multiple pages, which a one-time crawl can't see.

Repolog's keyword research includes real search volume, difficulty, and CPC per country market, with 20 research runs/month on Starter and 100 on Pro, pooled across the workspace. That's the ongoing layer; the scan is the diagnostic layer.

What an audit can't do

Be clear about the boundary:

• It can't fix content quality. A page can pass every technical check and still not rank because it doesn't answer the query well.
• It can't build backlinks. Off-page authority is outside any on-page scan.
• It can't tell you which keyword to target. It can grade a page against a keyword you've chosen, but the strategic choice is yours.
• It can't guarantee rankings. It removes obstacles; it doesn't create demand.

Treat the audit as a checklist that clears the path, not as the thing that does the walking.

Deciding whether to run one

Run an audit if you've never done one, if you've redesigned or migrated recently, or if rankings dropped without an obvious cause. Repolog offers a free homepage scan — one homepage per day, no signup — which is enough to see whether technical issues are holding you back. If you need ongoing tracking, keyword research, and multi-site management, the paid tier starts with a 7-day free trial. Start with the free scan; only move to a paid plan once you've confirmed there's a backlog of fixes worth tracking over time.

Google Lighthouse is an open-source automated auditing tool that loads a page in a real (headless) browser and scores it across five categories: Performance, Accessibility, Best Practices, SEO, and PWA. You run it from Chrome DevTools, the command line, or through PageSpeed Insights, and you get a report in roughly under a minute. It is most useful as a single-page diagnostic: it tells you what is slow or broken on that URL and what to change. It is not a site-wide crawler, so if you need to audit many pages at once, pair it with a broader audit platform.

Where Lighthouse runs

All three use the same underlying audit engine, so the category list and metric definitions are consistent. What differs is the environment and whether you get real-user data alongside the lab run.

The five categories

• Performance — how fast the page renders and how stable it is, scored from lab metrics.
• Accessibility — automated checks against WCAG rules: color contrast, alt text, form labels, heading and landmark structure, ARIA roles, focus order.
• Best Practices — general web hygiene: HTTPS, safe libraries, correct image aspect ratios, console errors.
• SEO — basic on-page signals: title, meta description, crawlability, legible font sizes, tap target spacing.
• PWA — installability and offline behavior. Only relevant if you're building a progressive web app; most sites can ignore it.

How the Performance score is built

The Performance number is a weighted blend of lab metrics, not a direct measurement of "speed." The core ones:

• FCP (First Contentful Paint) — when the first text or image appears.
• LCP (Largest Contentful Paint) — when the main content element finishes rendering. Usually the heaviest-weighted metric.
• TBT (Total Blocking Time) — how long the main thread is blocked by long tasks, which delays interactivity.
• CLS (Cumulative Layout Shift) — how much visible content jumps around during load.
• Speed Index — how quickly content is visually populated.

Each metric is compared against Google's thresholds and mapped to a 0–100 sub-score, then the sub-scores are combined with fixed weights. That's why two pages with the same LCP can still score differently — TBT or CLS can drag one down.

Reading the report and prioritizing fixes

Work top-down by impact, not by the order audits are listed:

1. Start with the metric that scored worst. If LCP is red, fix the largest element (usually a hero image or heading). If TBT is red, look for long JavaScript tasks.
2. Read the "Opportunities" section. These are estimated savings — e.g. "Properly size images," "Eliminate render-blocking resources," "Reduce unused JavaScript." Each one links to the exact elements involved.
3. Check "Diagnostics" for context the opportunities don't cover, like DOM size or main-thread work breakdown.
4. Fix accessibility and SEO items in the same pass. They're usually cheap: missing alt text, low contrast, a missing meta description.

The report tells you what failed and points at the elements; it does not rewrite your code. Treat each failing audit as a task with a specific target.

Why scores vary between runs

Lighthouse is a lab tool, so results depend on the run conditions:

• Throttling — default mobile emulation simulates a slow 4G connection and a mid-tier CPU. Change it and the score changes.
• Third-party scripts — ads, analytics, and A/B tools load inconsistently and can swing TBT.
• Server response time — a slow backend on one run inflates FCP and LCP.
• Browser extensions and local state — DevTools runs can be affected by what's loaded in your session.

To get consistent numbers: run the CLI with a fixed config, run several times and compare the median, and test in a clean profile or CI environment rather than your daily browser.

When Lighthouse isn't enough

Lighthouse audits one URL per run. It won't tell you that 40 of your 500 pages share the same broken template, and it doesn't track whether a fix held after the next deploy. For that you need a tool that crawls the whole site and re-checks over time.

For example, a platform like Repolog runs a headless browser against your page and executes 60+ checks in one pass — SEO, Core Web Vitals pulled from Lighthouse (FCP, LCP, TBT, CLS, Speed Index on mobile emulation), accessibility via axe-core against the WCAG 2 rule set, 19 read-only security checks, and AI-readiness checks (robots.txt access for GPTBot, ClaudeBot, PerplexityBot and Google-Extended, JSON-LD structured data, sitemap.xml and llms.txt presence). The practical difference is scope and workflow: Lighthouse gives you a deep single-page lab report; a multi-page audit tool gives you coverage and a ranked fix list across the site.

A sensible split: use Lighthouse while you're actively fixing a specific page, and a site-wide audit when you need to know which pages to fix first or confirm a fix stuck.

Core Web Vitals are three metrics Google uses to measure real page experience: LCP (loading), INP (interactivity), and CLS (visual stability). Each has published thresholds — good, needs improvement, poor — and each maps to a small set of common causes with known fixes. You measure them two ways: lab data from a tool like Lighthouse (a simulated run) and field data from real visitors (Chrome UX Report, Search Console). Lab data tells you what to fix; field data tells you whether it worked.

The three metrics and what each one measures

INP replaced FID (First Input Delay) as the interactivity metric. FID only measured the delay before the browser started processing the first interaction; INP samples interactions across the whole visit and reports a high-percentile value, so it catches slow responses that FID missed. If you see FID in older reports, treat INP as the current target.

Thresholds are evaluated at the 75th percentile of page loads, segmented by mobile and desktop. A page passes only when 75% of real visits hit the "good" band for all three metrics.

How to measure: lab data vs. field data

These answer different questions, and you need both.

Lab data (Lighthouse, PageSpeed Insights' "Analyze" tab) — a single simulated load on a throttled connection. It's reproducible, so it's good for debugging and for comparing before/after a fix. It is not what your users experience.

Field data (Chrome UX Report via PageSpeed Insights' top section, or Search Console's Core Web Vitals report) — aggregated from real Chrome users over the past 28 days. This is what Google's ranking systems actually see. It can be empty for low-traffic pages, in which case you have no field signal yet.

A practical workflow:

1. Run PageSpeed Insights on the URL. Read the field data first — if the page passes in the field, lab warnings are lower priority.
2. If field data is failing or missing, use the Lighthouse section to find the specific cause.
3. Fix, deploy, then re-check field data after the 28-day window rolls over. Lab scores update immediately; field data does not.

Repolog runs Core Web Vitals from Lighthouse (FCP, LCP, TBT, CLS, Speed Index) on mobile emulation inside a real headless browser load, scored against Google's thresholds, and returns a ranked report in about a minute with no signup — one homepage per day on the free scan. That's useful for a fast baseline; you still want field data to confirm real-world impact.

Common causes and fixes

LCP is slow

The usual culprits, in rough order of frequency:

• The LCP element is an unoptimized image. Serve it as WebP/AVIF, size it correctly, and add fetchpriority="high" to the hero image. Don't lazy-load the LCP image.
• Render-blocking CSS or fonts. Inline critical CSS, defer the rest, and preload the primary font file.
• Slow server response (high TTFB). LCP can't be faster than the server's first byte. Check caching, CDN coverage, and database queries on the critical path.
• Client-side rendering. If the hero content only appears after a JS bundle executes, the browser paints late. Server-render or statically generate the above-the-fold content.

INP is high

• Long tasks on the main thread. Break up JavaScript that runs for more than 50ms; yield to the browser between chunks.
• Heavy third-party scripts — tag managers, chat widgets, analytics. Load them after interaction or in a worker where possible.
• Expensive event handlers. Debounce input handlers and avoid layout reads/writes inside them.

CLS is high

• Images and iframes without dimensions. Always set width and height (or an aspect-ratio box) so the browser reserves space.
• Ads, embeds, and banners injected above existing content. Reserve a fixed slot.
• Web fonts swapping and reflowing text. Use font-display: optional or swap with a matched fallback metric.
• Late-injected DOM (cookie bars, promos) that pushes content down. Overlay instead of inserting into flow.

Where Core Web Vitals fit in a broader audit

Core Web Vitals are one input among several, and they interact with the rest. A page can pass all three metrics and still fail on SEO fundamentals (missing titles, broken heading hierarchy, no canonical), accessibility (contrast, form labels, ARIA), or security (missing HSTS, exposed .env). Repolog's scan bundles these: 60+ checks across SEO, performance, accessibility (axe-core against WCAG 2 rules, reported to the failing element), security (19 read-only checks including header and file-exposure tests), and AI readiness (18 checks covering GPTBot/ClaudeBot/PerplexityBot access in robots.txt, JSON-LD, sitemap.xml, llms.txt, and FAQ patterns). Each issue comes with its fix.

The reason to look at them together: a fix for one can regress another. Deferring a script to improve INP can delay the LCP element. Adding a consent banner for compliance can introduce CLS. Running the checks in the same browser load, as Repolog does, makes those trade-offs visible in one report instead of three.

Quick decision guide

• Just want to know if you pass? PageSpeed Insights field data, or Search Console's Core Web Vitals report.
• Need to debug a specific failing metric? Lighthouse in Chrome DevTools, with the performance trace open.
• Want a ranked list of everything to fix across SEO, speed, accessibility, security, and AI readiness, with the fix attached? Run a scan on your homepage — Repolog's free audit takes about a minute with no signup, and the paid tiers (7-day free trial, $0 due today) add keyword research runs, keyword-to-page mapping, and Search Console integration for cannibalization checks.

A website audit runs a set of automated checks against a live page and returns a ranked list of issues, each paired with a fix. On Repolog, one scan covers five areas — SEO, performance (Core Web Vitals), accessibility, security, and AI readiness — in about a minute, with no signup required for a single homepage scan. You use the results by working top-down through the ranking rather than trying to fix everything at once. This applies to any site you can point a scanner at; it does not require code changes, an SDK, or installing anything.

The five areas one scan covers

Each area answers a different question about the same page load.

Accessibility findings are reported down to the exact failing elements, which is what makes them actionable — you get the element, not just the rule name.

How a scan works in practice

1. Add your website. Enter a domain, or import sites you already manage. Nothing to install, no code changes, no SDK.
2. Run a scan. A real headless browser loads your page and 60+ checks run against it. The full report typically returns in under a minute.
3. Read the ranked report. Issues come back ordered, and every issue includes its fix.

The important detail is the headless browser: checks run against a real rendered page load, not a static HTML fetch. That is why performance and accessibility numbers reflect what a visitor's browser actually does.

How to prioritize the fixes

The ranking exists so you don't have to guess. A practical order:

• Fix anything that blocks indexing or crawling first. Canonical errors, robots.txt rules that lock out search or AI crawlers, and broken heading structure affect everything downstream.
• Then take the Core Web Vitals that are failing Google's thresholds. LCP and CLS tend to have the widest blast radius across rankings and user experience.
• Then accessibility failures with a specific failing element. Contrast and missing form labels are usually quick, bounded fixes.
• Then security headers and file exposure. Leaked .env, .git, or wp-config.php and exposed debug endpoints are worth treating as urgent even if they rank lower, because they are exposure rather than polish.
• Then AI readiness. Structured data, sitemap, llms.txt, and crawler access determine whether AI answer engines can cite you at all.

Re-scan after each batch. Because the report is ranked, the next scan shows whether your fix moved the issue or just changed its position.

When a free one-page scan is enough — and when it isn't

A free homepage scan (one per day, no signup) is enough when you want to:

• Sanity-check a single page before or after a redesign
• Confirm whether a specific problem (slow LCP, contrast failures, a missing sitemap) exists
• Evaluate the tool before committing

You need more than a one-page scan when the work becomes ongoing:

• Multi-page coverage. Issues on category, product, or article templates won't appear in a homepage scan.
• Keyword tracking. Repolog maps each tracked keyword to the page that should rank it, and the next scan grades that page against its keyword. Starter includes 20 research runs per month, Pro 100, pooled across the workspace.
• Search Console integration. This surfaces queries you already get impressions for and flags keywords cannibalized across multiple pages — something a single scan can't see.
• Team use. Importing sites you already manage and pooling research runs across a workspace implies more than one person or property.

Repolog offers a 7-day free trial with $0 due today for the signed-up product; the single homepage scan is the no-signup path. Pricing beyond the trial and the Starter/Pro research-run limits isn't specified in the available material, so check the pricing page before assuming a tier fits.

The short version

An audit checks five things — SEO structure, Core Web Vitals, WCAG accessibility, security exposure, and AI crawler readiness — against a real browser load, then ranks the findings. Use the ranking: fix crawl and indexing blockers, then failing vitals, then element-level accessibility issues, then security exposure, then AI readiness. Start with the free single-page scan; move to tracking and Search Console integration once you're fixing templates and keywords rather than one page.

Free SEO tools can handle a surprising amount of real work: checking backlinks, auditing on-page elements, tracking keyword positions, and generating reports. For a small site or a beginner, they cover most day-to-day tasks. The catch is not capability but capacity — free tools usually limit how much data you can pull, how often you can pull it, and how precisely you can filter it. Understanding those limits lets you decide what to do for free and when paying becomes the sensible next step.

Mapping Common SEO Tasks to Free Tool Coverage

Most SEO work falls into a handful of recurring jobs. Here is how free tools typically perform on each.

The pattern is consistent: free tools answer "what is roughly true right now" well, and "what exactly changed over time" poorly.

The Practical Limits You Will Hit

Free tools are not crippled versions of paid ones by accident. The limits exist because crawling, storing, and serving link and ranking data is expensive. Expect these constraints:

• Usage caps. A fixed number of queries per day, or a character/word limit on content tools. Once you hit the cap, you wait.
• Sampled data. Backlink checkers often show a subset of links rather than the complete profile. Two tools can report very different totals for the same site, and both can be "correct" within their own index.
• Delayed or cached results. Ranking positions and link counts may be days or weeks old. Nothing free is truly real-time at scale.
• Fewer export and filtering options. You may see results on screen but not be able to download them, sort by multiple columns, or filter out low-quality links.
• No saved history. Without stored snapshots, you cannot see whether a metric improved or declined over the past month.

None of this makes free tools useless. It means you should treat their output as a directional signal, not a precise measurement.

How to Read Backlink Counts and Authority Scores

Two numbers cause the most confusion: backlink count and domain authority-style scores.

Backlink counts vary by index. If one tool says 400 links and another says 1,200, the difference is usually coverage, not error. Use a single tool consistently so your own trend line is comparable, and treat the absolute number as approximate.

Authority scores (often labeled DA, DR, or similar) are third-party estimates, not metrics search engines publish. They compress many signals into one number. That makes them convenient for quick comparison and dangerous as a sole decision criterion. A high score does not guarantee rankings, and a low score does not mean a page cannot rank for a specific query.

A safer habit: look at three things together — referring domains (more meaningful than raw link count), the relevance of linking sites to your topic, and whether your own score is trending up or down over time.

A Simple Free-Tool Workflow for a Small Site

This loop works for a blog, a local business site, or a small store. It assumes you have no budget and limited time.

1. Audit. Run your key pages through an on-page checker. Record the title, meta description, H1, word count, and any missing alt text in a simple spreadsheet.
2. Fix. Correct the obvious issues first: duplicate or missing titles, thin content, broken internal links, slow-loading images. These are the highest-return fixes and cost nothing.
3. Track. Pick 10–20 keywords that matter. Check their positions weekly with a free tracker or manually, and log the date and position.
4. Compare. Once a month, check referring domains and your authority-style score. Note the direction, not the exact figure.
5. Repeat. Re-audit pages that lost positions or gained traffic. Update content rather than adding new pages endlessly.

Keep one spreadsheet with three tabs: pages, keywords, and links. Consistency matters more than tool choice.

When a Task Has Outgrown Free Tools

Consider paying when one of these becomes true:

• You need to track more keywords than the free cap allows, or you need daily updates.
• You must export full backlink lists for outreach or disavow work.
• You are auditing a site with hundreds or thousands of pages and need a complete crawl.
• You need historical data to prove whether a change worked.
• Multiple people need to work in the same tool with shared access.

Until then, free tools plus a disciplined spreadsheet will carry a small site a long way.

Common Pitfalls to Avoid

• Trusting one metric. No single score decides rankings. Combine authority, relevance, and traffic data.
• Expecting real-time rankings. Free trackers lag. Judge trends over weeks, not hours.
• Comparing across tools. Different indexes produce different numbers. Pick one and stay with it.
• Chasing link counts. Ten relevant links from real sites beat a thousand low-quality ones.
• Skipping the fix. Auditing without acting is just collecting data. The value is in the changes you make.

Free SEO tools are genuinely useful for auditing, tracking, and learning. Their limits are about scale and precision, not usefulness. Start with the workflow above, watch your trend lines, and upgrade only when a specific task clearly demands more than the free tier provides.