How We Do Technical SEO: Every Step, in the Open

The report said “technical issues: fixed”. Your site stayed slow — and half of it was invisible to Google.

Ask owners who have been through it and the story repeats almost word for word. The monthly report carried a healthy-looking site score and a line saying the technical issues had been fixed. Meanwhile the site still loaded slowly on a phone, pages the owner assumed were on Google were not there at all, and nobody could say which issues had supposedly been fixed, or when, or what the numbers were before – nothing like how we work technical SEO. In the version owners describe most bitterly, the truth only surfaced when they changed provider: the new audit found warnings the old reports had quietly left out — in one reported case, underreported by hundreds of points — and problems that had sat untouched for the entire contract. Some owners found out even later, and worse: a site that went down repeatedly after a handover, losing content and images, while the paperwork said everything was handled.

That is possible because technical SEO is the easiest work in the world to claim and the hardest for an owner to see. A fixed title shows on the page; a fixed redirect chain does not. So this page exists to remove the hiding place. Below is the exact process we follow on a client’s website, step by step: what we check, what we fix, in what order, and — most importantly — what paperwork you receive so you can re-check every line yourself, free, without taking our word for any of it. Technical work done properly is invisible. The fix log is the receipt.

What is technical SEO, in plain words?

Technical SEO is everything underneath your pages that decides whether Google can find them, read them, store them and show them quickly. Three words explain most of it:

  • Crawl — Google’s reader visiting your pages. Google sends an automated reader (the crawler) to follow links and read what is there. If it cannot reach a page, nothing else about that page matters.
  • Index — Google’s library. After reading a page, Google decides whether to store it in the index, the library it actually answers searches from. A page that is not in the library cannot appear in results, however good it is.
  • Speed — how fast the page loads and responds on a real phone. Google measures this with three checks called Core Web Vitals, and its “good” lines are plain numbers anyone can test against: the main content should load within 2.5 seconds, the page should respond to a first tap or click within 200 milliseconds, and the content should not jump around as it loads — a layout-shift score of 0.1 or less.

If on-page SEO is what your pages say, technical SEO is whether Google can properly hear them. The two are separate jobs with separate processes — which is why how we do on-page SEO has its own page, and this one is only about the plumbing underneath.

How we work technical SEO: the process, step by step

A typical first month runs in this order. Timings are the shape of the work, not a promise of rankings by a date — no honest agency can promise those. The order itself is deliberate: find everything first, fix in impact order, then prove the fixes by measuring again.

Step 1 — The full crawl audit: every page, every status (Week 1)

We start by crawling the whole site — sending a reader through every address on it, the same way Google’s reader travels, and recording what it finds at each one. Every page gets a status: working (it loads normally), moved (it forwards visitors somewhere else — fine once, a problem when forwards chain together, page A sending you to B sending you to C, each hop slowing the visitor and wasting Google’s time), missing (the address leads nowhere — the “page not found” error), or broken (the server itself failed to answer). The crawl also catches broken links between your own pages and pages buried so deep in the site that Google’s reader rarely reaches them.

What you see: the complete list — every address on your site, its status, and the problem found, in plain words. Not a score. A list you can click through yourself, line by line, in your own browser.

Step 2 — The indexation check: what is actually in Google’s library (Week 1)

Next, three lists are laid side by side: the pages that exist (from the Step 1 crawl), the pages in your sitemap (the list of addresses your site hands to Google, saying “these are my pages”), and the pages Google has actually indexed — stored in its library, checked in Search Console, the free Google account that shows what Google holds about your site. The gaps between those three lists are where businesses quietly lose money: pages in the sitemap that return “missing” errors, important service pages that exist but were never indexed, and orphaned pages — pages that exist but no other page on the site links to, so Google’s reader seldom finds them and visitors never do. A page can be beautifully written and completely absent from Google; this step is where that gets caught.

What you see: the reconciliation itself — one table: this page exists / it is in the sitemap, yes or no / it is in Google’s library, yes or no / if not, the reason we found. Every “no” gets an explanation or a fix in Step 9’s list.

Step 3 — Speed, measured per page type — not one homepage score (Week 2)

Speed is then measured properly: not once, on the homepage, but on each page type — your homepage, a service page, a location page, a blog post — because each type is built from a different template and they do not perform alike. A fast homepage proves nothing about the service page customers actually land on. Each type is measured against the three Core Web Vitals lines from earlier (2.5 seconds loading, 200 milliseconds response, 0.1 layout shift), and we record what is holding it back. The usual culprit is render-blocking resources — files the page insists on loading before it shows anything, so the visitor stares at a blank screen while scripts and styles queue up ahead of the words and pictures they came for.

What you see: a before-measurement for each page type — the three numbers, next to Google’s three lines, with the blocking files named. These are the numbers the fix log (Step 10) will be judged against. No before-number, no proof — so the before-numbers always exist.

Step 4 — The mobile rendering check: what Google’s phone reader actually sees (Week 2)

Google mostly judges your site through its mobile reader — it reads the phone version of your pages first. So we compare two views of each important page: what a visitor sees on their phone, and what Google’s mobile reader receives. The gap between them is a real and common failure. Much of it comes from JavaScript-rendered content — words and pictures that only appear after extra code runs in the browser. If that code is slow, blocked, or broken, the visitor may eventually see the page while Google’s reader saw something much thinner — or nearly blank — and stored that thin version in the library. Menus that do not open for the reader, buttons too small or crowded to tap, and text hidden behind tabs the reader never opens all get checked the same way: as Google encounters them, not as the desktop site displays them.

What you see: a short gap list per important page — visible to your visitors / visible to Google’s reader / what differs, and what we intend to do about each difference.

Step 5 — Structured data (schema): only what is genuinely true (Weeks 2–3)

Some pages carry extra behind-the-scenes information called schema: your business details, your services, your opening hours, the questions and answers on the page. It helps Google understand the page and can earn extra details in your result. Our rule is the same strict one we apply on-page: schema is added or kept only where it describes something real and visible on the page. That means, above all, no fake review stars. The technical name for the trick is a self-declared AggregateRating — code in which a business awards itself a star rating, typed in by whoever built the site rather than earned from real reviews. It is one of the most common technical cheats we find, because it can make stars appear next to a result the business never earned — until Google strips them, which it does. And it is one you can check yourself: if your result shows stars, ask where the reviews behind them live. If nobody can show you real reviews, on a real platform, matching that number, the stars are written in code, not earned.

What you see: a list of the schema on each page and what it claims — every claim checkable against the words and reviews a visitor can actually find.

Step 6 — Canonicals and duplicates: one main address for every page (Week 3)

The same page often exists at several addresses without the owner knowing: with and without “www”, the secure and unsecure versions, a version with a code added for tracking or filtering. Each copy is a duplicate — the same content wearing different addresses — and duplicates split Google’s attention: it has to guess which one you mean, and it does not always guess the one you would choose. The fix uses a canonical — a note in the page’s code saying “this address is the main one; count the others towards it.” We check that every page’s note points at the right address, because a wrong one is worse than none: a page whose canonical points elsewhere is politely asking Google to leave it out of the library.

What you see: the duplicate groups found — the addresses that serve the same page — and the main address chosen for each, so you can see nothing important was pointed at the wrong place.

Step 7 — Security basics: the padlock, everywhere, always (Week 3)

A page served over HTTPS — the version with the padlock in the browser — encrypts what passes between your visitor and your site; the old unsecure version leaves it exposed and modern browsers warn visitors about it. We check that the security certificate is valid, that every address forwards to the secure version (once, not in chains — Step 1 again), and that no secure page quietly loads unsecure pieces, which breaks the padlock. Then the finishing step: HSTS, an instruction your site gives browsers saying “always ask for the secure version of me, never the unsecure one.” It is switched on only once the secure version works everywhere — in the wrong order it can lock visitors out — and once on, it closes the gap where a customer typing your plain address could be intercepted before the forward happens.

What you see: the security checklist itself — certificate valid, every address landing on the padlock in one hop, no unsecure pieces inside secure pages, HSTS on or honestly marked “not yet, and why”.

Step 8 — Crawl waste: where Google’s reader spends its time (Week 3, where the data exists)

Google’s reader does not visit every site endlessly; it spends a limited amount of visiting effort, and wasted visits are visits your important pages did not get. Where the records exist, we look at where that effort is going. The best record is the server log — your hosting’s own diary of every visit to the site, including Google’s reader: which addresses it asked for, and what it got. Where logs are not available, Search Console’s crawl statistics give a smaller version of the same picture. Crawl waste is the pattern this step hunts: the reader spending hundreds of visits on dead addresses, endless forwards, and duplicate filter pages, while a key service page is visited rarely. One honesty rule applies to this step in particular: if the log data cannot be obtained, the report says so. A crawl-waste finding is never invented to fill the section.

What you see: the most-wasted-on addresses and how often your important pages are actually being visited — with the source named (server log or Search Console), so you know exactly what the claim rests on.

Step 9 — Fixes, in impact order — not easiest-first (Week 3)

Only now — with the full picture from Steps 1–8 — are fixes ordered, and the order is fixed by one question: what is costing you customers? The sequence runs: indexation first (a page outside Google’s library cannot rank at all, so missing and orphaned money pages outrank everything), then crawl blockers and errors (missing pages, broken forwards, server failures), then speed on the page types customers land on, then the clean-up work — canonicals, schema, security finishing — and polish last. Each fix is listed before it happens, with its expected effect and, where a change carries any risk, how it will be staged and undone if needed. Nothing is fixed silently in a different order because it was quick to do.

What you see: the prioritised fix list before the work starts — the order, the reason for the order, and the chance to question any line of it before a single change is made.

Step 10 — Re-crawl, re-measure, and a fix log you can re-check line by line (Week 4, then after every fix batch)

When a batch of fixes is done, the site is crawled again and the measurements are retaken — same page types, same method as the before-numbers in Step 3. Then the paperwork that this whole page exists for: the fix log. Every fix gets a line: the date, the address, the problem found, what was changed, the before measurement and the after measurement. The re-crawl summary is reported as three honest counts — problems found, problems fixed, problems still open — and the still-open ones stay on the list, in writing, until they are closed. One honest caveat belongs here: a re-crawl proves your site is fixed; Google re-reads and updates its library on its own schedule, so an indexation fix can be complete on your site days before Google’s library reflects it. The log records both dates — fixed, and seen in Google — rather than pretending they are the same day.

What you see: the fix log itself, kept updated as work continues, and the standing invitation this page is built around: pick any line, re-check it free (a browser for statuses, Google’s own PageSpeed test for speed, a site: search for the library), and if a line does not check out, ask us why — in writing.

Our way vs the cut-price way — technical edition

The cut-price wayWhat it does to youOur way
One-line fix claims — “technical issues fixed ✓” in a monthly report, no list, no dates, no numbersNothing can be checked, disputed, or handed to the next provider; the same “fixes” can be billed again next quarterA line-by-line fix log — date, address, problem, change, before and after measurements, re-checkable free at any time (Step 10)
A plugin install sold as optimisation — a caching or “speed” plugin is installed, the report calls the site optimised, and no measurement is ever takenA plugin is a tool, not a result; badly matched plugins can conflict with each other and slow the site further while the report says the oppositeMeasured before, measured after — per page type, against Google’s three speed lines (2.5s / 200ms / 0.1), with the blocking files named (Step 3)
Fake schema stars — a star rating typed into the code by the agency, not earned from real reviewsStars you never earned, displayed until Google strips them — and a trust problem with any customer who looks for the reviews and finds noneHonest schema only — every claim in the code describes something real and visible on the page or a real platform (Step 5)
Indexation never checked — reports talk about rankings while service pages sit outside Google’s library entirely, or the sitemap hands Google a list of dead addressesYou pay to optimise pages Google has never stored; no ranking report can reveal it, because the page simply never appearsSitemap–index reconciliation — existing pages, sitemap pages and indexed pages laid side by side, every gap explained (Step 2)
Silent changes, silent breakages — settings and code altered without record, staging or warning; the owner finds out from a customer that something stopped workingNo record of what changed means no way to undo it; breakage is discovered by the people you least want discovering itStaged fixes + re-crawl verification — risky changes staged and reversible, every change logged, the whole site re-crawled and re-measured after each batch (Steps 9–10)
Set and forget — “fixed” once, never re-checked, while updates, new plugins and new pages quietly undo the work over the following monthsThe fix decays invisibly — the exact reason so many owners discover the last agency’s work “didn’t hold”Re-audit on a rhythm — a re-crawl after every fix batch, after any big site change, and a scheduled re-check while you are with us, all written into the same fix log

What you receive — the full list

No more and no less than this:

  • The full crawl list — every address on your site, its status, and the problem found, in plain words.
  • The index reconciliation table — exists / in the sitemap / in Google’s library, with the reason for every gap.
  • Before-measurements per page type — the three speed numbers next to Google’s three lines, with the blocking files named.
  • The prioritised fix list — what will be fixed, in what order, and why that order, agreed before the work starts.
  • The fix log — every fix with its date, what changed, and the before-and-after measurements.
  • The re-crawl confirmation — problems found, problems fixed, problems still open, with the still-open ones carried on the list until they close.

What is deliberately not on this list: a promise that Google will index every page (Google chooses what enters its library, and a thin or duplicate page may rightly stay out until the page itself deserves otherwise), a perfect speed score on every page (a single tool score is a reading, not the goal — the goal is real pages loading inside Google’s lines for real visitors), or a ranking position by a date. Those are the promises the cut-price version makes because it never intends to show its working. This page is the working.

Check it yourself — five free checks

You do not have to hire anyone to get a first read on your site’s technical health. Our technical self-check guide walks through the full version, but the five checks at its heart are these, and every one is free:

  1. Count what Google holds. Search site:yourwebsite (your real address) and compare the rough count with the number of pages you believe you have. A big gap — far fewer pages than exist, or hundreds more than you ever made — is a Step 2 problem.
  2. Test a money page, not the homepage. Put a service page’s address into Google’s free PageSpeed test and compare the three numbers with the three lines: 2.5 seconds, 200 milliseconds, 0.1. That page, on a phone, is what customers get.
  3. Open your own sitemap. Your address followed by /sitemap.xml should load and list real, working pages. Dead addresses on that list are your site handing Google a map to nowhere.
  4. Click to every important page. Starting from your homepage, can you reach every service and location page by following links, in a few clicks? A page no click-path reaches is an orphan — and what you cannot reach by links, Google’s reader rarely reaches either.
  5. Check your own stars. If star ratings show next to your name in Google, find the reviews behind them on a real platform. If nobody can show you those reviews, the rating was typed into the code — Step 5 explains why that matters.

And if the worry is bigger than your site’s plumbing — if you suspect the problem is what a previous provider did off your site — start with our guide to checking whether your SEO agency built spammy backlinks. It is the same principle applied to links: your own accounts, your own checks, no one’s word taken for anything.

Frequently asked questions

Will technical fixes break my site?

Honest answer: a change to code or server settings always carries some risk, which is exactly why the process is built the way it is. Fixes are ordered before they start (Step 9), risky ones are staged — tried safely before they go live — and reversible, and the whole site is re-crawled straight after each batch (Step 10), so a breakage is caught by us within the work, not by your customers afterwards. What breaks sites in the stories owners tell is the opposite pattern: silent, unrecorded changes nobody can undo because nobody wrote down what was touched. The fix log is the protection as much as the proof.

How often should a technical audit be repeated?

A full audit at the start, a re-crawl after every batch of fixes, and a fresh check after anything big changes — a redesign, a new theme, a pile of new plugins, a hosting move. While a site is actively worked on, we also re-check on a set rhythm rather than waiting for a problem to announce itself, because the commonest cause of technical decay is ordinary life: updates overwrite settings, new pages arrive without links, an old page gets deleted and its forwards forgotten. Every re-check goes into the same fix log, so the site’s technical history stays in one readable place.

My last agency installed a speed plugin and the score looked fine. Is that the same as fixed?

No — and this is the most common technical misunderstanding we meet. A plugin is a tool; it is not a measurement. A single score, usually taken from the homepage on a desktop, says nothing about the service page a customer lands on from their phone, and a tool score is a laboratory reading — Google’s lines are judged on real visits to real pages. “Fixed” has a specific meaning in our process: the before-numbers exist, the blocking files were named, the work was done, the same page types were measured again the same way, and both sets of numbers are in the fix log. If your last provider cannot produce the before-numbers, there is no evidence anything was fixed — only that a plugin was installed.

Why didn’t the last agency’s “fixes” hold?

Usually one of four ordinary reasons, none of them mysterious. The fix was a setting rather than a repair, and a later update quietly reset it. A new plugin conflicted with the old arrangement. New pages and changes reintroduced the same problem — a deleted page here, a missing link there — and nobody re-crawled to notice. Or the fix was real but partial: the homepage was sped up while the templates underneath it were not. Notice what all four have in common: without a fix log, there is no way to tell which one happened to you, or when. That record — what changed, on what date, measured how — is what makes a fix maintainable instead of temporary.

How is this different from your on-page and off-page work?

Technical SEO is whether Google can reach, read, store and quickly show your pages — the plumbing underneath. On-page SEO is what those pages say. Off-page SEO is what the rest of the internet says about you — links, listings and reviews. The three are separate jobs with separate processes, which is why each has its own page in this section. A provider doing all three should be able to show you all three workings — if only one is ever described to you, ask about the other two.

Where this fits

Technical work is the foundation the rest stands on: a dedicated page for every service is the strongest page-level move a local business can make, and it counts for nothing if that page is slow, orphaned, or missing from Google’s library. If you are still deciding whether your business needs SEO at all, who needs local SEO gives the honest answer by business type, including who does not. If you want to know what it costs, our UK SEO packages page puts the prices, the inclusions and the never-included list in writing. And if you would rather start with evidence than with a sales call, the free local SEO audit checks your site the way this page describes and reports what it finds — yours to keep, whichever way you decide.