Every Marketing SEO Audit check

Missing JSON-LD structured data leaves search engines without machine-readable signals to understand your content type, organization identity, or page purpose. Google's Rich Results — star ratings, FAQ dropdowns, sitelinks search boxes — are only available to pages with valid schema.org markup. Without it, your content competes on raw text signals alone, systematically losing SERP features to competitors who implement schema-org Organization and WebPage schemas. This is a direct findability penalty, not a cosmetic gap.

Why this severity: Critical because all Rich Results eligibility and schema.org knowledge-graph signals depend on JSON-LD being present and syntactically valid; absence forfeits the entire structured-data surface.

A JSON syntax error in any `<script type="application/ld+json">` block silently discards the entire schema — Google logs a parse failure and ignores the block, removing that page from Rich Results eligibility. Beyond syntax, schema-org Article and schema-org WebSite define required properties that must be present for Google to trust and surface the markup: an `Article` missing `datePublished` will not appear in Top Stories carousels regardless of content quality. Invalid structured data is equivalent to no structured data from Google's perspective, making this a direct ranking signal failure.

Why this severity: High because any syntactically invalid JSON-LD block or missing required property silently disqualifies that page from Rich Results, wasting implementation effort and suppressing SERP visibility.

When Google displays breadcrumbs in search results — the path hierarchy shown beneath the page title — it pulls from `BreadcrumbList` schema-org markup, not from the visible UI component on your page. Interior pages without `BreadcrumbList` JSON-LD miss the SERP breadcrumb display even if a visible breadcrumb component exists. For sites with nested URL structures (`/docs/getting-started`, `/blog/category/post`), breadcrumb trails in search results improve click-through rates by communicating page context before the user clicks. A visible breadcrumb UI without corresponding schema is a common implementation gap that leaves this benefit unclaimed.

Why this severity: Low because missing breadcrumb schema costs click-through rate on interior pages but does not affect crawlability, indexation, or core ranking signals directly.

schema-org Organization and schema-org WebSite on the homepage signal your site's entity identity to Google's Knowledge Graph. Without this markup, Google infers your brand entity from text alone — a slower, less reliable process that can delay sitelinks eligibility, suppress your knowledge panel, and produce incorrect brand associations in AI-generated search overviews. The `sameAs` property linking to your social profiles is particularly important: it allows Google to merge your website entity with your social presence, which affects how brand queries are answered across Search, SGE, and third-party AI tools that consume structured entity data.

Why this severity: Info because the absence does not break crawling or ranking directly, but it slows entity recognition and delays sitelinks and knowledge panel eligibility — a recoverable gap with no urgency.

schema-org Article and schema-org BlogPosting unlock Top Stories carousel eligibility on mobile Search and Google Discover — two high-traffic surfaces where content without Article markup cannot appear. Google's documentation states that `datePublished`, `author`, and `image` are required for rich result eligibility; a blog post missing these fields is indexed as a plain page, not an article, losing carousel placement to competitors whose posts carry complete markup. For any site relying on organic content discovery, this is a direct distribution gap: the same words, worse placement, because the schema signals are missing.

Why this severity: Info because most blog traffic still flows through standard search results even without Article schema, but the absence closes Top Stories and Discover carousels entirely — a meaningful lost channel for content-driven sites.

Structured data that contradicts visible page content is treated as deceptive markup under Google's Structured Data Policies, and offending pages lose rich result eligibility or get manual actions applied. When an Article's JSON-LD `headline` is hardcoded while the H1 renders from `post.title`, every new post ships a schema lie. Findability collapses for the affected templates because rich snippets disappear and crawlers downrank the URL.

Why this severity: Medium because impact is per-template loss of rich results, not site-wide deindexation or data exposure.

Brand-only or shared template titles collapse your SERP real estate: Google rewrites weak titles, competitors with descriptive titles outrank you for the queries your page actually targets, and your CTR drops because users scanning results cannot tell what the page offers. A `/pricing` route titled `YourApp` is invisible to anyone searching `pricing` plus a category term, wasting every inbound link you earn.

Why this severity: Critical because the `<title>` is the single highest-weighted on-page ranking signal and every indexable page inherits the defect.

A generic H1 like `Welcome` tells Google nothing about the page's topic, and the search engine falls back to anchor text and body text to guess intent — usually wrong. For content-driven sites this directly suppresses rankings on the exact queries the page should win, and for templated pages sharing a layout-level H1 every URL competes against itself for the same phrase.

Why this severity: High because the H1 is the second-strongest on-page signal after `<title>` and defects propagate across every page sharing the layout.

Repeating the same phrase across consecutive H2s triggers Google's keyword-stuffing heuristics and can suppress the page below competitors with natural headings. Generic section labels like `Overview`, `Details`, `More` give crawlers no topical structure, so the page loses eligibility for the long-tail subheading-match snippets that drive most informational traffic. Readers also skip the page because headings carry no scent.

Why this severity: Medium because stuffing degrades rankings and readability but does not remove the page from the index entirely.

Thin pages with 2–3 sentences of body copy lose ranking competitions against competitors who answer the query more completely — Google's Helpful Content system explicitly targets shallow pages and can demote the entire site, not just the offenders. Listing pages that show only titles and dates leave the crawler nothing to rank, so category and archive URLs stay stranded on page 3+ of results indefinitely.

Why this severity: Medium because thin content suppresses rankings sitewide under Helpful Content but does not directly deindex pages.

Anchor text is one of the strongest signals Google uses to understand what the target page is about. `click here` and `read more` pass zero topical context, so every internal link squanders the link-equity distribution that descriptive anchors would provide. Icon-only links with no accessible text also fail WCAG 2.2 SC 2.4.4 (Link Purpose), stacking an accessibility violation on top of the SEO loss.

Why this severity: Low because impact is gradual equity dilution rather than immediate ranking collapse or indexation failure.

Duplicate URLs serving the same content split ranking signals across variants, so no single URL accumulates enough authority to rank. Paginated routes without self-referencing canonicals tell Google to ignore pages 2+, stranding inventory and archive content. Parameter permutations (`?sort=price`, `?sort=name`) multiply into thousands of crawlable URLs that consume crawl budget and dilute PageRank across near-identical pages.

Why this severity: Critical because signal-splitting across duplicate URLs suppresses rankings for every affected template simultaneously.

A canonical pointing to HTTP while the site serves HTTPS tells Google to index the insecure URL — which may not exist — and the page drops out of results. Conflicting canonical declarations (one in the layout, one in the page) force Google to pick arbitrarily, often choosing the wrong target. Cross-domain canonicals caused by copy-paste errors hand your ranking authority to the wrong host entirely.

Why this severity: Critical because a malformed canonical can deindex the correct URL or transfer authority to a wrong destination sitewide.

Canonicalizing every paginated page to page 1 instructs Google to drop pages 2+ from its index entirely, so deep archive content, older blog posts, and paginated product listings become invisible to search. Base URL and `?page=1` variants serving identical content without disambiguation split the signal between two URLs, and neither ranks as well as a single consolidated URL would.

Why this severity: Medium because the defect deindexes deeper paginated content but does not affect the first page's rankings.

Multilingual sites without hreflang tags serve the wrong language to the wrong audience: French users see the English page in search results, bounce rates spike, and Google interprets the engagement signal as a quality problem. Missing `x-default` means Google has no fallback for locales outside your declared set, so international queries return nothing. Relative URLs in hreflang are ignored entirely by crawlers.

Why this severity: Medium because impact scales with international traffic and only affects multilingual deployments.

Googlebot allocates a fixed crawl budget per site, and every request to a noindex admin or debug route is a request it did not spend on a page you actually want ranked. Noindex URLs in the sitemap send contradictory signals — submit this URL, but do not index it — which Google's Search Console flags as a coverage error and which slows indexation of legitimate new content.

Why this severity: Info because crawl-budget inefficiency mostly affects large sites and rarely suppresses individual page rankings directly.

Sort, filter, and UTM parameters multiply a single product listing into hundreds of crawlable URLs serving the same content. Link equity splits across every variant, so no single URL accumulates enough authority to rank. UTM parameters used inside internal `<Link>` components are especially toxic: they contaminate the canonical URL set and pollute analytics with self-referral traffic that looks like external campaigns.

Why this severity: High because parameter sprawl can create thousands of duplicate URLs, dwarfing the impact of a single misconfigured template.

Without Search Console verification you cannot see the queries driving traffic, detect indexation regressions, receive manual-action notifications, or submit sitemaps for priority crawling. Sites running blind for months accumulate undiagnosed issues — missing pages, schema errors, Core Web Vitals regressions — that GSC would have surfaced on day one. No analytics means no attribution either.

Why this severity: Info because absence blocks observability but does not directly harm rankings or user experience.

Numeric-only dynamic routes like `/products/12345` pass zero keyword signal to Google — the URL contributes nothing to ranking, and when users share the link on social or paste it in chat, the preview reveals nothing about what they will find. Underscores in slugs merge words into a single token (`small_business_seo` becomes one indivisible phrase) while hyphens let Google treat each word as a separate match target.

Why this severity: Low because URL structure is a minor ranking signal compared to title, headings, and content quality.

Google completed its mobile-first indexing rollout in 2023: the mobile version of your page is now the canonical version for ranking. Content hidden on mobile via CSS — using patterns like `hidden md:block` on headings or product descriptions — is treated by Googlebot as absent content. This directly reduces keyword coverage for those pages: if your desktop hero contains the H2 keywords that your page targets, and that H2 is hidden on mobile, those keywords lose their heading-weight signal in the index. The iso-25010:2011 performance-efficiency concern compounds this: serving non-performant mobile experiences alongside hidden content produces two independent ranking penalties.

Why this severity: Critical because mobile-first indexing means content hidden on mobile is absent from the indexed version, directly reducing keyword coverage and heading-weight signals for every affected page.

Largest Contentful Paint (LCP) is a Core Web Vital in Google's Page Experience ranking signal — poor LCP (over 2.5 seconds) is a documented ranking penalty on mobile. The most common cause is a hero image loaded without a preload hint: the browser discovers the image only after parsing the HTML, then waits for it to download before marking LCP complete. A bare `<img>` tag without `priority` on a Next.js page means the image competes with scripts and stylesheets for bandwidth. iso-25010:2011 performance-efficiency maps directly to this: delayed LCP degrades both user experience and search ranking simultaneously, and the fix is a single prop change.

Why this severity: High because a poor LCP score is a confirmed Page Experience ranking signal on mobile, and above-the-fold images without priority loading are the leading cause of failing the 2.5-second LCP threshold.

Cumulative Layout Shift (CLS) is a Core Web Vital — a score above 0.1 degrades Page Experience ranking on mobile. The most common cause is images rendered without explicit `width` and `height` attributes: the browser reserves no space for the image before it loads, so the page shifts downward when the image appears, displacing content the user was reading. A secondary CLS source is cookie consent banners or chat widgets that inject above existing content post-render, pushing the viewport. Beyond ranking, high CLS creates a frustrating user experience where buttons move before users can click them — a direct conversion impact measurable in A/B tests. iso-25010:2011 performance-efficiency covers both the ranking and usability dimensions.

Why this severity: High because CLS above 0.1 is a confirmed Core Web Vital failure that degrades Page Experience ranking and produces a measurably worse user experience that affects engagement and conversion rates.

Interaction to Next Paint (INP) replaced First Input Delay as a Core Web Vital in March 2024 — poor INP (over 200ms) is now a ranking penalty in the Page Experience signal. INP measures the worst interaction delay across a user session, making synchronous JavaScript in event handlers the primary culprit: a button click that triggers a heavy filter operation blocks the main thread, the browser cannot paint the response for hundreds of milliseconds, and Google records a poor INP event. iso-25010:2011 performance-efficiency captures this: sites shipping large monolithic bundles without code splitting routinely fail INP thresholds because every interaction competes with the cost of parsing and executing the full bundle.

Why this severity: Medium because poor INP affects Page Experience ranking on mobile and creates frustrating interaction delays, but the impact is session-wide rather than page-load immediate, making it less urgent than LCP or CLS failures.

Mobile viewport misconfiguration — specifically `user-scalable=no` or `maximum-scale=1` — violates WCAG 2.2 SC 1.4.4 (Resize Text) and WCAG 2.2 SC 2.5.1 (Pointer Gestures), both Level AA. Beyond the accessibility compliance impact, Google's mobile usability guidelines explicitly list zoom-disabled viewports as a mobile usability error that can suppress rankings. Fixed-width containers causing horizontal scroll on mobile (e.g., `min-width: 1200px`) similarly trigger Google's mobile usability report as a crawl-quality signal. These are configuration-level mistakes that affect every page simultaneously — not a per-page optimization gap but a baseline setup error with site-wide ranking consequences.

Why this severity: Low because these configurations affect usability and accessibility compliance rather than direct ranking signals, but the WCAG 2.2 violation scope is site-wide and the fix requires only removing a few CSS or HTML attributes.