Navigation that changes between pages

A menu rendered from a data source that differs by template, where one template passes a filtered set.

A conditional that hides entries in a context — a checkout flow, a landing page — and applies more broadly than intended.

A menu cached per template, where one cache entry was populated before a new item was added.

A second, older menu component still used by some templates while the rest moved to a new one.

A permission or locale condition that is true on some pages and false on others for reasons unrelated to navigation.

Sections become reachable from some pages and not others, which a visitor experiences as the site losing parts of itself.

Crawl paths become inconsistent, so a section linked only from the templates a crawler visits least is discovered least.

The pages that lose entries are frequently the deep content pages, which is where a visitor most needs a way back out.

And it undermines the learned model: a menu that changes is one a visitor stops relying on.

The defect is a difference between pages, so it is invisible on any one of them.

Whoever checks usually opens the home page, which is the template most likely to be correct.

Nothing errors, nothing looks broken, and the menu on the page being viewed is complete.

Which is why it needs a comparison across templates rather than a review of a page.

It is also why it survives for a long time: every individual check passes.

The same entries, in the same order, on every page that has a primary navigation.

The key pages — contact, legal, about, the main sections — linked from it everywhere.

Deliberate exceptions are fine and should be deliberate: a checkout flow with reduced navigation is a decision, not a drift.

A current-page indicator changing is not an inconsistency — that is the menu doing its job.

Breadcrumbs may legitimately differ per page, since they describe position rather than structure.

Render the navigation from one source in one component, used by every template.

Remove the conditions that filter it, or scope them narrowly enough that they cannot apply by accident.

Where a reduced navigation is intentional, make it an explicit variant rather than a condition inside the default.

Invalidate every cached copy when the menu changes, rather than per template.

Add a check comparing the rendered navigation across a sample of templates, which catches the next occurrence automatically.

Open one page of each template type and compare the navigation entries side by side.

Include the deep pages — an article, a product, a detail page — which are the ones most likely to differ.

Compare at a phone viewport as well, since the mobile menu is frequently a different component.

Check that the key pages appear on every one of them.

Crawl the site and compare the link sets found on each page, which does the comparison mechanically.

`structure.navigation` compares the navigation of every crawled page and checks that key pages are linked from it, which is this problem directly.

`structure.menu` analyses the primary navigation region on each page, including its entries and its dead ones.

`structure.navigation_ux` measures depth and orphan candidates, which are the downstream consequences of an inconsistent menu.

`mobile.navigation` and `mobile.menu` examine the same region at a phone viewport, where the component frequently differs.

`structure.footer` reports the footer region separately, since it carries a second set of links with the same consistency question.

The footer carries the links visitors look for before deciding whether to trust a site — contact, legal notice, privacy — and it drifts for the same template reasons.

A footer present on the main templates and absent from a landing page removes exactly those links from the page most likely to be a first impression.

It also frequently repeats the same destination several times, which adds nothing and dilutes what is there.

Because it is at the bottom, nobody notices it missing during a visual check of the page they opened.

Which makes it worth comparing across templates alongside the primary navigation rather than separately.