Search & Technology
Google Doesn’t Hate Your Website. It Might Just Be Confused.
Low search visibility isn’t always a quality problem. Sometimes the source, the rendered page and the sitemap each tell Google something different.
One of the riskiest sentences in technical SEO is a reasonable one: “The page looks fine.”
I investigated a multilingual site where hundreds of pages were barely being seen by Google. In the published case, that was 612 pages, and 538 of them had no impressions at all in Search Console (for the site and period described in the case study). A page can look fine and still be part of the problem. The question that eventually mattered was: fine to whom, and at what moment?
The short answer: when a group of pages gets almost no search visibility, “the content isn’t good enough” is only one possible explanation. Another is that your site is sending contradictory signals about those pages, and no single place you look shows the contradiction. To find out, check each version of the page on its own (the HTML as first delivered, the page after JavaScript has run, the sitemap, and any pre-rendered copy), then compare them.
The point of this note: when pages go unseen, test what each version of your site says about them before you decide what is wrong with the content.
Key takeaways
- A page can say one thing before JavaScript runs and another after.
- A list built by code, such as a sitemap, can quietly leave out a whole group of pages.
- The moment you find one cause is the moment you are most likely to stop looking.
- Separate what you observed from what you inferred, and write down what you still don’t know.
The explanation I liked too much
My first explanation was neat. I suspected every page sent the same bare HTML before JavaScript ran, so Google would have nothing to tell them apart. It sounded technical, it sounded plausible, and it fitted the symptom.
It was also a guess. I knew I hadn’t yet checked whether Google could read what each page became afterwards, and I let the neat story run ahead of that gap anyway. That is the habit worth admitting to, because it is an easy way to go wrong: a hypothesis that is good enough to feel like a finding.
What changed my mind was not a clever tool. It was the decision to stop asking one question (“why is Google ignoring these pages?”) and start asking another: what is each part of the site saying about them?
A page has more than one version
On a modern site, “the page” is not one thing. At least four versions of it can exist at once, and each is a kind of witness:
- The HTML as first delivered. What a crawler receives before any script runs. This is what “view source” shows.
- The page after scripts have run. What a browser, or a search engine’s renderer, ends up with.
- The sitemap. The list of pages the site says it wants found.
- The pre-rendered copy. A ready-made version of the page, built in advance, for crawlers and for speed.
Witnesses can disagree without any of them being wrong; each one simply saw a different moment. The trouble is that you usually only ask one of them.
Witness one: the page after it wakes up
The live pages could be indexed. The version of the code waiting to be deployed, though, contained a rule applied in the browser after load that would have marked those pages as not to be indexed.
Picture a sign that only gets hung on the shop door after the shop has opened. Anyone who reads the door before opening time sees nothing wrong, and the sign still changes what happens next. “View source” shows the door before opening time.
This is not exotic. Google’s documentation says JavaScript can add or change a robots meta tag, and describes a process of crawling, then rendering, then indexing. It also says pages are queued for rendering unless a robots tag or header tells Google not to index them. So an instruction in the first HTML and one added later by a script take different routes, and the first thing a crawler fetches can differ from what it eventually indexes.
Witness two: the list that forgot
The second cause had nothing to do with the first. The tools that build the sitemap and the pre-rendered copies of the site were both written around one family of pages. The 612 pages belonged to another family, so neither list included them.
Think of a guest list written for one party and quietly reused for another. Nobody on the door is being unfair. The names simply aren’t there. A sitemap is a list of the pages a site wants found, and if the generator never lists a group of pages, it is easy to miss that they are absent, because nothing on the page looks wrong.
In an isolated copy, the sitemap and the pre-rendered set each gained all 612 pages. That was a test, not a deployment: the fix was prepared and handed to the developers to review and apply.
Why finding one cause is the risky moment
There were two causes, they were independent, and neither could be seen by opening the page source.
Whichever you find first will feel like the answer. It explains something, it is real, and it is satisfying to write down. Stopping there would have meant reporting one cause and missing the other. An early report in the investigation did imply a single cause, and it was corrected once the layers were compared.
The practical rule is simple. A cause that explains part of the symptom is a lead, not a conclusion. Ask what else could be true at the same time.
What I can and can’t say
This is the habit I’d keep from the whole exercise. Sorting what you know into four labels stops a good story from running ahead of the evidence.
| Label | In this case |
|---|---|
| Observed | 612 pages barely seen, 538 with no impressions (Search Console). The live pages were indexable. The sitemap and the pre-rendered set left that group of pages out. In an isolated copy, both lists grew by 612. |
| Inferred | The waiting code would have marked those pages as not to be indexed once deployed. |
| Unknown | Whether either cause explains the low impressions. What changed after the fix, if anything. |
| Test next | Compare equal time windows before and after any change. Inspect a sample of pages live, not only as last indexed. |
I can describe the mechanism. I can’t say it explains the 538 pages with no impressions: the live pages were still indexable, the causes concern code that hadn’t gone live, and the impressions figure comes from Search Console, not from the code. Those are separate pieces of evidence, and I haven’t shown a link between them. I also haven’t claimed a result from the change, because I haven’t shown one.
That restraint is not modesty for its own sake. A write-up that says only what it can support is the one a reader can act on and check.
A short check you can run on your own site
You don’t need special tools. You need patience and a habit of comparing. Pick three pages from the group you are worried about, not your best-performing page, and for each one:
- Look at the HTML as first delivered. Use “view source” in your browser, or fetch the page with a command-line tool. Both show it before scripts run. Note the title, the canonical URL and the robots instruction.
- Look at the rendered page. Use the URL Inspection tool in Search Console and open the rendered HTML. Its help page says the default view shows the indexed version, not a live test, so run the live test when you want to know what the page looks like now.
- Compare the two. Differences in title, canonical or robots instructions are the first place to look.
- Check that each page appears in your sitemap and in any pre-rendered set. Count them. Don’t assume.
- Remember what “indexed” means. The same help page says “URL is on Google” doesn’t guarantee the page appears in results.
- Label what you know and what you’ve guessed. Use the four labels above, and revisit the guesses.
How to get better at this
The technical details above will change. In my view the habits underneath them last longer than any single checklist.
- Keep a log of your hypotheses, with the date and what would prove each one wrong. Reading it back is humbling and useful.
- Compare sources instead of trusting one. Two views that agree are evidence. Two that disagree deserve a closer look than either one alone.
- Say what would change your mind before you look, not after.
- Write down the unknowns as carefully as the findings. They are the next piece of work.
- Re-check after a fix using the same method and equal time windows, so you compare like with like.
What I’d check first now
I’d stop asking “why is Google ignoring these pages?” and start asking “what is each part of my site saying about them?” The first question blames a search engine. The second can be answered with evidence, and it keeps you honest about the answers you don’t have yet.