Site icon All About HTML

SEO Audit Checklist: 20 HTML Checks for Any Web Page

Seo audit

Table of Contents

Toggle

SEO Audit Checklist: 20 HTML Checks for Any Web Page

An SEO audit is a structured inspection of one web page against the things search engines actually use to understand, rank, and display it. It is not a score from a tool, and it is not a redesign. It is a checklist you work through in order, marking each item pass or fail, and writing down the fix for every fail before you touch any code. The page you are auditing might be your own — a blog post that stopped growing, a landing page that never ranked — or a client’s page you have been asked to review. Either way the method is the same, and it takes about an hour once you know the checks.

This guide gives you the 20 checks that matter most for an HTML page, grouped the way a search engine reads a page: first, can it find and index the page at all; then the titles, meta tags, and headings; then the content; then the links; then the images; then speed, mobile, and layout; and finally the structured data and social-sharing tags. Each check tells you what to look for, exactly how to test it with free tools you already have, what a pass looks like, and how to fix a fail. At the end you get a reusable HTML audit template — a page with checkboxes you can save, open in any browser, and use on every page you audit from now on.

You do not need a paid SEO tool for any of this. A browser, its developer tools, the W3C validator, and Google’s free PageSpeed Insights and Search Console cover all 20 checks. Paid tools automate the same inspection; they do not check anything different. What they save is time on large sites. On one page, the manual method in this guide is faster, and you will understand the page better at the end of it, because you will have read its HTML instead of reading a report about its HTML.

One warning before you start: an audit finds problems; it does not fix them. The temptation after a long audit is to fix everything in one sitting, starting with the easiest items. Resist it. Fix in the order this guide gives you — indexing first, then titles and headings, then content, then links, images, and performance — because a page Google cannot index gains nothing from a better title, and a page with the wrong title gains nothing from a faster image. The scoring section at the end tells you how to rank the fixes when time is short.

Quick Takeaways

What an SEO Audit Actually Checks

A search engine does four things with a page, in this order: it discovers the page, it reads the page, it decides what the page is about, and it decides whether the page deserves to rank for that topic. An audit mirrors those four steps. The first group of checks is discovery and indexing: can a crawler reach the page, is it allowed to index it, and does it know the page exists. The second group is the reading step: the title, the meta description, the headings, and the document structure that tell the crawler what the page says. The third group is the aboutness step: does the content match what a searcher actually wants, is it original and complete, and is it current. The fourth group is the ranking step: do other pages link to it, does it load fast enough on a phone, and does it carry the structured data that earns rich results.

What an audit does not check is just as important. It does not judge whether the page is well written — that is an editorial judgement, not an HTML one, and this guide flags thin or duplicated content but does not rewrite it. It does not measure your competitors, and it does not predict a ranking position. A page can pass all 20 checks and still sit on page two, because ranking also depends on the strength of competing pages and the authority of the site. What passing all 20 checks guarantees is simpler and more valuable: nothing in the page itself is holding it back. When a page passes the audit and still does not rank, the problem is the content or the competition, and you know where to look next.

The 20 checks are written for a single page, not a whole site. A site-wide audit repeats the same checks across many pages and adds questions about the site’s structure — how pages link to each other, whether the sitemap is complete, whether whole sections are accidentally blocked. That is a bigger job, and it starts exactly here: audit one page properly, then repeat the process on the next ten most important pages, and the site-wide picture assembles itself from the results. Do not audit the whole site before you have audited one page well.

The 20 checks at a glance

GroupChecksWhat it answers
A. Indexing1–4Can search engines find, reach, and index this page?
B. Titles, meta & headings5–8Does the page say what it is about, clearly and once?
C. Content9–11Does the content match the searcher’s intent, and is it original and current?
D. Links12–13Do the page’s links work, and do they point somewhere useful?
E. Images & media14–15Do images help the page instead of slowing it down?
F. Speed, mobile & layout16–18Does the page load fast and stay stable on a phone?
G. Structured data & social19–20Does the page carry the markup that earns rich results and good link previews?

Before You Start: The Free Toolkit

You need five free tools, and you already have four of them. The first is your browser’s developer tools — press F12 in Chrome, Edge, or Firefox — which let you inspect the live HTML, check the console for errors, and test the page at phone width. The second is view-source: type view-source: before any URL in the address bar and you see the HTML exactly as the server sent it, which is what a crawler sees before JavaScript runs. The third is the W3C validator at validator.w3.org, which checks the page’s HTML for errors. The fourth is Google PageSpeed Insights at pagespeed.web.dev, which measures loading speed and layout stability on mobile and desktop. The fifth is Google Search Console, which is free but requires you to verify ownership of the site — if you do not have access, skip the checks that need it and note them as unverified rather than guessing.

Keep a simple audit sheet as you work: one row per check, with three columns — the check name, pass or fail, and the fix. The HTML template at the end of this guide is exactly that sheet, as a page you can reuse. Work through the checks in order and write the fix down the moment you find a fail, while the evidence is in front of you. Audits go wrong when the auditor finds ten problems, fixes none of them, and then cannot remember which URL had which problem. The sheet is the audit; the fixes come after.

Set aside an hour for your first audit of a page, and about thirty minutes once you have done a few. If a check takes more than five minutes, you are probably overthinking it — mark it as “needs a closer look”, move on, and come back to it after the other nineteen are done. An audit that finishes with two items flagged for a second look is far more useful than an audit abandoned at check six.

Group A — Can Search Engines Find and Index the Page?

Check 1: Is the page indexed at all?

The first check is the most basic and the most commonly failed: does Google have this page in its index? A page that is not indexed cannot rank for anything, no matter how good its content is. The quickest test needs no tools at all. Search Google for the page’s exact URL, or use the site: operator with the page’s address, like site:allabouthtml.com/html-meta-tags-seo/. If the page appears, it is indexed. If nothing appears, it is not — or Google has not got around to it yet, which is a different problem with a different fix.

The more reliable test is in Search Console, under URL Inspection: paste the URL and read the verdict. It tells you whether the page is indexed, when Google last crawled it, and — if it is not indexed — why not. The reasons fall into a small set: the page is blocked by robots.txt, the page carries a noindex directive, Google found a canonical tag pointing elsewhere, or Google crawled the page and decided it was a duplicate of another page. Each of those has its own check later in this group, so for now just record the verdict. A page that has been live for months and is still not indexed is a fail, and its cause is almost always one of checks 2 to 4.

Pass: the page appears in a site: search, or Search Console reports it as indexed. Fail: the page does not appear, or Search Console reports it as not indexed. Fix: find the cause in checks 2–4, fix it, then request indexing in Search Console and wait — re-crawling takes days, not minutes, and requesting it twice does not make it faster.

Check 2: Robots meta tag and robots.txt

A page can be perfectly written and still invisible, because something told the crawler not to look at it. There are two places that instruction can live. The first is the page itself: a <meta name="robots" content="noindex"> tag in the head tells search engines not to index this page. The second is the site’s robots.txt file, which can block whole paths — a staging directory, an admin area, or, in the classic disaster, the entire site. Open the page, view the source, and search for robots. Then open yoursite.com/robots.txt and read it.

A noindex tag is legitimate on pages that should never appear in search results: a thank-you page after a form submission, an internal search-results page, a printer-friendly duplicate. On a normal article or landing page it is a fail — usually left over from a staging copy that was published without removing it, or added by a plugin setting nobody remembers changing. The robots.txt version is worse, because it blocks the crawler from even fetching the page, so Search Console cannot tell you much about it. The most dangerous line in any robots.txt file is Disallow: /, which blocks everything. If you see it on a live site, that is the whole audit: fix that first, and nothing else matters until it is fixed.

<!-- PASS: no robots meta tag at all, or an explicit index instruction -->
<meta name="robots" content="index, follow">

<!-- FAIL on a public article page: tells search engines not to index it -->
<meta name="robots" content="noindex, follow">

Pass: no noindex on the page, and robots.txt does not block the page’s path. Fail: a noindex tag on a page that should rank, or a Disallow rule covering the page. Fix: remove the noindex tag or the blocking rule, then request re-crawling in Search Console.

Check 3: Canonical tag — does it point at the right URL?

The canonical tag tells a search engine which URL is the real version of a page when several URLs show the same content — with and without a trailing slash, with tracking parameters, with http and https versions. It lives in the head as <link rel="canonical" href="...">. The check is simple: view the source, find the canonical tag, and compare its href with the URL in the address bar. They should match, or differ only in a way you intended, such as a tracking parameter stripped off.

Three failures are common. The first is a canonical tag pointing at a different page entirely — usually a copy-paste error from another post, or a template that hard-codes one URL. That tells Google the page is a duplicate of the other page, and Google will index the other one instead. The second is a missing canonical tag on a page whose content is reachable at several URLs; without one, Google picks a canonical itself, and it may pick the wrong one. The third is a canonical tag pointing at a URL that redirects or returns a 404, which confuses the crawler and wastes its budget. A self-referencing canonical — the tag pointing at the page’s own URL — is the safe default for a normal article page, and it is what this check wants to see.

<!-- PASS: self-referencing canonical on the article's own URL -->
<link rel="canonical" href="https://allabouthtml.com/html-meta-tags-seo/">

<!-- FAIL: canonical points at a different page — Google will index that one instead -->
<link rel="canonical" href="https://allabouthtml.com/some-other-post/">

Pass: a canonical tag is present, it points at the page’s own URL, and that URL returns a 200 status. Fail: the tag is missing, points elsewhere, or points at a redirect or a 404. Fix: set a self-referencing canonical in the page template or the SEO plugin, and make sure the URL it names is the live one.

Check 4: URL structure and the sitemap

A good URL is short, readable, and says what the page is about: allabouthtml.com/html-meta-tags-seo/ tells a human and a crawler what to expect before the page loads. The check is a judgement call, not a pass-or-fail on a single rule, but four things are worth recording. First, is the URL short enough to read at a glance — under about 60 characters is a good guide. Second, does it contain the page’s topic words, separated by hyphens, with no dates, no ID numbers, and no meaningless parameters. Third, does it use lowercase throughout, because servers can treat Page and page as different URLs. Fourth, is the page listed in the site’s XML sitemap — open yoursite.com/sitemap.xml and search for the URL. A page missing from the sitemap is not necessarily unindexed, but it is a page the site never told Google about, and on a large site that is often the reason a page is never crawled.

Do not change a live URL just because it is ugly. Changing a URL breaks every link pointing at it, and the redirect that fixes that costs the page some of its accumulated authority. Record a bad URL as a note for the next time the page is substantially rewritten, and fix it then with a proper 301 redirect. The exception is a URL that is actively harmful — one containing a session ID, a tracking parameter baked in, or a date that makes evergreen content look stale. Those are worth fixing now, with the redirect in place before the change goes live.

Pass: a short, readable, lowercase URL containing the topic words, listed in the XML sitemap. Fail: a long or parameter-filled URL, or a page missing from the sitemap. Fix: add the page to the sitemap (usually automatic in a good SEO plugin); leave a merely ugly URL alone until the next rewrite, and fix a harmful one now with a 301 redirect.

Group B — Titles, Meta Descriptions, and Headings

Check 5: The title tag

The title tag is the single most important on-page element in an SEO audit. It is the blue link in a search result, the text in the browser tab, and the strongest signal of what the page is about. View the source and find <title>. Then check three things: it exists, it is the right length, and it says the right thing. The right length is 50–60 characters — long enough to carry the topic, short enough that Google shows it whole instead of cutting it off with an ellipsis. The right content is the page’s topic in natural words, with the most important words first, and the site name at the end only if there is room.

The failures are predictable because the same mistakes appear on almost every site. The commonest is a missing or empty title tag, usually on a page built by a template that nobody finished. Next is a duplicated title: every page on the site carrying the same title, most often the site name alone, which tells Google nothing about any individual page. Then the title that is too long — a full sentence stuffed with keywords — which Google truncates, hiding the words that matter. And the title that puts the site name first and the topic last, so the visible part of the search result is branding and the topic is cut off. A title that repeats the same keyword twice is not clever; it reads as spam to a human and gains nothing with a search engine.

Write the title for the search result first and the browser tab second. A reader scanning ten results decides in a second, and the title is most of what they see. If the page’s topic is a question, the title can be the question. If the topic is a guide, the title should say so and say what the guide covers. Never put the year in a title unless the page is genuinely time-sensitive — a title with 2024 on it makes a still-good page look stale in 2026.

<!-- PASS: 50–60 characters, topic first, one keyword phrase, natural wording -->
<title>HTML Meta Tags: Complete SEO List Every Page Needs 2026</title>

<!-- FAIL: site name first, topic buried, and far too long to display -->
<title>All About HTML | Learn HTML From Zero to Hero | Meta Tags Guide for SEO and Beginners</title>

<!-- FAIL: duplicated on every page — tells Google nothing about this page -->
<title>All About HTML</title>

Pass: a unique title of 50–60 characters, topic words first, no keyword repetition. Fail: missing, duplicated, over 60 characters, or site name first. Fix: rewrite the title in the SEO plugin or template — this is the highest-value single fix in most audits, and it takes two minutes.

Check 6: The meta description

The meta description is the grey text under the title in a search result. Google has said for years that it does not use the description as a ranking factor, and that is true — but the description decides whether a searcher clicks, and the click is what brings the visit. The check is threefold: the description exists, it is 120–155 characters long, and it reads like a reason to click. View the source and find <meta name="description" content="...">. Count the characters — a description under 120 characters wastes space Google would have given you, and one over 155 gets cut off mid-sentence, usually at the least convenient point.

A good description names the topic, names the benefit, and names the reader. “Learn HTML meta tags with working examples, a complete 2026 checklist, and copy-paste code — for beginners building their first site” does all three in one sentence. A bad description is a keyword list, a sentence copied from the middle of the article, or the site’s generic tagline repeated on every page. The last of these is the commonest failure: a template that fills every page with the same description, so ten search results all carry the same grey text and the searcher has no reason to prefer one over another. Each page needs its own description, written for that page’s topic, just as each page needs its own title.

One more thing to check: does the description match the page? A description that promises a checklist the page does not contain, or a free download that does not exist, earns a click and loses the visitor in seconds. That bounce tells Google the result disappointed the searcher, which is worse than not being clicked at all.

<!-- PASS: 120–155 characters, topic + benefit + reader, unique to this page -->
<meta name="description" content="Learn HTML meta tags with working examples, a complete 2026 checklist, and copy-paste code for beginners building their first site.">

<!-- FAIL: the same generic description on every page of the site -->
<meta name="description" content="Learn HTML from zero to hero. Tutorials, guides, and examples for beginners.">

Pass: a unique description of 120–155 characters that names the topic, the benefit, and the reader. Fail: missing, duplicated, under 120 or over 155 characters, or a keyword list. Fix: write one sentence per page in the SEO plugin; start with the pages that already get impressions in Search Console, because those are the descriptions searchers actually see.

Check 7: Exactly one H1

Every page needs exactly one <h1>, and it should be the page’s main heading — the title of the article, visible at the top of the content. View the source or use developer tools and count the h1 elements. Zero is a fail: the page has no main heading, and both readers and search engines have to guess what it is about. Two or more is also a fail: the page claims two topics, and the structure is ambiguous. The usual causes are a template that puts the site name or the logo in an h1 on every page, and a page builder that lets every section heading be an h1 by default.

The H1 does not have to match the title tag word for word, and usually it should not — the title tag is written for a search result, the H1 is written for a reader who has already arrived. But the two must agree on the topic. A title tag about meta tags and an H1 about HTML basics tells Google the page cannot decide what it is, and tells the reader they may have clicked the wrong result. The H1 should contain the page’s main topic words, naturally, and it should be the first heading a reader meets. A page whose first heading is an h2 and whose h1 sits in the footer has its structure upside down.

<!-- PASS: one H1, the article title, at the top of the content -->
<main>
  <h1>HTML Meta Tags: Complete SEO List Every Page Needs</h1>
  <p>Every web page carries a set of meta tags...</p>
</main>

<!-- FAIL: the logo is an H1 on every page, and the article title is another H1 -->
<header>
  <h1>All About HTML</h1>
</header>
<main>
  <h1>HTML Meta Tags: Complete SEO List Every Page Needs</h1>
</main>

Pass: exactly one h1, the article’s main heading, at the top of the content. Fail: zero, or two or more. Fix: change the logo or site name to a plain link or a p element, and make sure the article title is the only h1 on the page.

Check 8: Heading order — H2s and H3s in sequence

Headings are the page’s outline. A screen reader user navigates a page by jumping from heading to heading, and a search engine reads the same outline to understand the page’s structure. The rule is simple: headings must run in order, with no level skipped. One h1, then h2 elements for the main sections, then h3 elements for sub-points inside a section. An h3 directly under an h1, with no h2 between them, is a hole in the outline. An h2 after an h3 that belongs to a different section is a section that was never properly closed.

The commonest failure is using headings for their size rather than their meaning: an h4 chosen because it looks the right size for a caption, or an h2 used as a styled banner that has nothing to do with the section below it. Headings are not a styling tool. If a piece of text needs to look like a heading but is not part of the outline, style a p element to look like one instead. The second commonest failure is the page that has no headings at all below the h1 — a wall of paragraphs that no reader can scan and no screen reader user can navigate. A 3,000-word article with one heading is a fail, however good the paragraphs are.

To test it, open developer tools and run a quick outline check, or use a browser extension that lists the page’s headings in order. Read the outline as a table of contents: it should tell the whole story of the page in ten or fifteen lines, with each line clearly belonging to the section above it. If the outline reads like a random list, the page’s structure needs reworking before anything else is fixed.

Pass: headings run h1 → h2 → h3 with no level skipped, and the outline reads as a sensible table of contents. Fail: skipped levels, headings used for styling, or long stretches with no headings. Fix: restructure the sections so each h3 sits inside an h2 section, and replace style-only headings with styled paragraphs.

Group C — Content: Does It Match the Search?

Check 9: Search intent — does the page answer the query it targets?

A page can be technically perfect and still fail, because it answers the wrong question. Search intent is what the searcher actually wants when they type a query: information, a how-to, a comparison, a download, or a purchase. A query like “html meta tags” wants a list and an explanation. A query like “html meta tags generator” wants a tool. A page that gives a long essay to someone who wanted a tool, or a tool to someone who wanted an explanation, will not rank well for that query, because searchers leave it quickly and Google notices.

The test is a search. Type the page’s target query into Google and look at the top five results. Are they the same kind of page as yours — guides, lists, tools, videos? If the top results are all step-by-step guides and your page is a short definition, the page is the wrong shape for the query, and no amount of title tuning will fix it. Read the top result’s headings: they show what searchers expect the answer to contain. If the top results all cover a sub-topic your page never mentions, that sub-topic is a gap in your page, and it is the first thing to add.

Intent also changes over time. A query that once wanted a definition can start wanting a comparison as the market matures, and a page written three years ago can quietly fall out of step. This is why an audit is worth repeating once a year on the pages that matter most: the page has not changed, but the search results around it have.

Pass: the page’s format and depth match the top results for its target query, and it covers the sub-topics those results cover. Fail: the page is the wrong format for the query, or it misses a sub-topic every top result covers. Fix: reshape the page to the winning format, and add the missing sub-topic as a new section.

Check 10: Thin, duplicated, or copied content

Thin content is a page that says very little: a few sentences where a searcher needed a guide, a product page with no description, a tag page that is only a list of links. The test is not a word count — a short page can be exactly right for a narrow question — but a comparison with the query. If the top results for the query are 2,000-word guides with examples and your page is 200 words with no examples, the page is thin for that query. If the page is 200 words because the question genuinely takes 200 words to answer, it is fine. Judge thinness against the competition, not against an arbitrary number.

Duplicated content is a different problem: the same text appearing on more than one URL of your own site, or copied from another site. Internal duplication usually comes from templates — the same introductory paragraph on every category page, or a product description repeated across ten near-identical pages. Search engines pick one version to show and ignore the rest, so the duplicates are invisible and the original is weakened. Use a site: search for a distinctive sentence from the page: if it appears on more than one of your URLs, you have duplication to fix. Copied content from another site is worse — it can only ever rank below the original — and it is usually the result of a content import nobody checked. The fix for internal duplication is to rewrite one version properly and canonicalise or redirect the others; the fix for copied content is to rewrite it in your own words, with your own examples.

Pass: the page’s depth matches the query’s competition, and a distinctive sentence from it appears on no other URL. Fail: the page is far shorter than competing results, or its text appears on other URLs. Fix: expand thin pages with examples and a FAQ, rewrite duplicated pages, and canonicalise or redirect the copies.

Check 11: Freshness — dates, versions, and dead claims

A page does not go stale all at once; it rots one claim at a time. A guide that says “as of 2023” in 2026, a code example using a deprecated attribute, a screenshot of an interface that no longer exists, a link to a tool that has shut down — each one is a small signal that the page is no longer maintained, and together they are enough to push a page down the results. The check is a read-through with fresh eyes: read the page as a new visitor would, and note every date, version number, product name, and external claim. Then check each one. Is the date still honest? Is the version still current? Does the tool still exist?

Two things deserve special attention. The first is the published date. A page whose date says 2023 but whose content was updated in 2026 should show both dates — originally published and last updated — so readers and search engines can see it is maintained. A page that hides its date entirely is not more evergreen; it is just less trustworthy. The second is code examples. HTML changes slowly, but attributes do get deprecated — the <font> tag, the align attribute, <center> — and a guide that still teaches them as current practice is actively misleading its readers. Run every code example in the page through the W3C validator as part of this check; a code block that does not validate is a claim the page cannot back up.

Pass: dates are honest and current, version numbers and tool names check out, and every code example validates. Fail: stale dates, deprecated code, dead tools, or claims that no longer hold. Fix: update the claims, refresh the code examples, and show a visible “last updated” date on the page.

Group D — Links: Do They Work, and Do They Help?

Check 12: Internal links — does the page connect to the rest of the site?

A page with no internal links is an island. Search engines discover pages partly by following links from other pages, and a page nobody links to is a page the crawler may never find — and a page a reader cannot navigate away from is a page that ends the visit. The check is to count the internal links in the article body, ignoring the site’s navigation menu and footer, which appear on every page and do not count as links from this page. A long article should have at least three to five internal links: one to a related guide, one to the next step in the same topic, and one to a broader overview or hub page.

Quality matters more than quantity. A link whose anchor text is “click here” tells the reader and the crawler nothing about the destination. A link whose anchor text is the destination’s topic — “the complete list of HTML meta tags” — tells both exactly what to expect. Check each link’s destination as you count: a link to a page that has itself been deleted or redirected is worse than no link, because it sends readers and crawlers into a dead end. Also check that the page is itself linked from somewhere sensible — the hub page for its topic, a related article, or the site’s category page. A page that links out generously but is linked from nowhere is still an island, just a generous one.

<!-- PASS: descriptive anchor text, pointing at a live related guide -->
<p>Start with the <a href="https://allabouthtml.com/html-meta-tags-seo/">complete list of HTML meta tags</a> before you audit anything else.</p>

<!-- FAIL: meaningless anchor text, and a link that goes nowhere useful -->
<p>For more information, <a href="/page-not-found/">click here</a>.</p>

Pass: three or more descriptive internal links in the body, all to live pages, and the page is linked from at least one sensible place. Fail: no internal links, “click here” anchors, or links to dead pages. Fix: add links to related guides with descriptive anchors, and link the page from its topic hub.

Check 13: Broken links and outbound links

Every link on the page — internal and external — should work. A broken link is a small failure on its own, but a page full of them tells a crawler the page is unmaintained, and tells a reader the site cannot be trusted. The test is to click every link, or run a link checker over the page. Internal links should return a 200 status. External links should return a 200 as well, or at least not a 404: a link to a page that has moved should be updated to the new address, and a link to a site that no longer exists should be removed or replaced with a live source.

Outbound links deserve a second look beyond whether they work. Every external link is a vote of confidence in the destination, and a page that links to low-quality or irrelevant sites weakens its own standing. Check that each outbound link goes to an authoritative source for its claim — the specification, the official documentation, a reputable guide — and that it opens in a way that does not strand the reader. An external link that opens in the same tab takes the reader away from your page with no way back except the back button; opening external links in a new tab, with rel="noopener", keeps the reader’s place. That attribute matters for security as well as usability: without it, the destination page can reach back into your page through the window.opener object.

<!-- PASS: external link, new tab, noopener set, authoritative destination -->
<a href="https://html.spec.whatwg.org/multipage/semantics.html" target="_blank" rel="noopener">the HTML specification</a>

<!-- FAIL: external link, same tab, no noopener, and the destination is a 404 -->
<a href="https://example.com/old-guide-that-moved">an old guide</a>

Pass: every link returns a 200, outbound links go to authoritative sources, and external links use target="_blank" with rel="noopener". Fail: any 404, or external links without noopener. Fix: update or remove broken links, and add rel="noopener" to every external link that opens in a new tab.

Group E — Images and Media

Check 14: Alt text on every image

Every image on the page needs an alt attribute, and the attribute needs to describe the image, not the file. Alt text has two jobs: it tells a screen reader user what the image shows, and it tells a search engine what the image is about — which is how images end up in image search results. View the source and search for <img. Each one should carry an alt attribute with a short, specific description. An empty alt="" is correct only for a purely decorative image, one that adds nothing to the content — a divider, a background flourish. A content image with an empty alt is a fail, and an image with no alt attribute at all is a fail twice over, because the screen reader will read out the file name instead.

The commonest failures are easy to spot. The first is alt text that describes the file instead of the picture: alt="IMG_4821.jpg" or alt="image". The second is alt text stuffed with keywords: alt="html meta tags seo guide meta tags html tutorial" reads as spam and helps nobody. The third is alt text on a screenshot that says “screenshot” without saying of what — a screen reader user learns nothing, and neither does a search engine. Write the alt text the way you would describe the image to someone on the phone: what it shows, in one sentence, with the topic words only where they belong naturally. A chart showing heading levels deserves “Diagram of HTML heading levels from H1 to H6 in a page outline”; a photo of a code editor deserves “HTML code open in a text editor with the head section highlighted”.

<!-- PASS: describes the image, one sentence, topic words where they belong -->
<img src="heading-levels-diagram.png" alt="Diagram of HTML heading levels from H1 to H6 in a page outline" width="800" height="450">

<!-- FAIL: file name as alt text, and no dimensions — see check 18 -->
<img src="IMG_4821.jpg" alt="IMG_4821.jpg">

Pass: every content image has a specific, one-sentence alt attribute; decorative images use an empty alt="". Fail: missing alt attributes, file names as alt text, or keyword-stuffed alt text. Fix: write real alt text for every image, starting with the ones in the article body.

Check 15: Image file sizes and formats

Images are the heaviest part of most pages, and the commonest reason a page loads slowly. The check is to look at every image’s file size and format. A photograph saved as a PNG can be ten times heavier than the same photograph saved as a JPEG; a simple diagram saved as a JPEG can be heavier and uglier than the same diagram as a PNG or an SVG. The modern formats — WebP and AVIF — are smaller than both for most images, and every current browser supports WebP. The rule is simple: photographs as JPEG or WebP, graphics and diagrams as PNG, SVG, or WebP, and nothing over a few hundred kilobytes unless the image genuinely needs it.

Check the dimensions too. An image displayed at 800 pixels wide does not need to be a 4,000-pixel original — the browser downloads all 4,000 pixels and shrinks them, and the visitor pays for the bandwidth. Resize images to the size they are displayed at, or a little larger for high-density screens, and no larger. Then check whether the page uses responsive images: a srcset attribute lets the browser pick a smaller file for a phone and a larger one for a desktop, instead of sending the desktop file to everyone. A page with one large image per section and no srcset is a page that is slow on every phone that visits it.

<!-- PASS: responsive image, modern format first, sensible sizes -->
<img src="heading-levels-800.webp"
     srcset="heading-levels-400.webp 400w, heading-levels-800.webp 800w, heading-levels-1200.webp 1200w"
     sizes="(max-width: 600px) 400px, 800px"
     alt="Diagram of HTML heading levels from H1 to H6 in a page outline"
     width="800" height="450" loading="lazy">

Pass: photos as JPEG or WebP, diagrams as PNG, SVG, or WebP, files sized to their display dimensions, srcset where an image appears at more than one size. Fail: oversized originals, PNG photographs, or no responsive images. Fix: convert and resize the worst offenders first — the largest file on the page is usually the biggest single speed win in the whole audit.

Group F — Speed, Mobile, and Layout

Check 16: Loading speed and Core Web Vitals

Speed is a ranking factor, but the audit treats it as a reader problem first: a page that takes five seconds to become readable loses visitors before they have read a word. The test is Google PageSpeed Insights — paste the URL, run it, and read the mobile score first, because most search traffic is mobile. The report gives three numbers that matter, called Core Web Vitals: Largest Contentful Paint (LCP), how long until the main content appears, which should be under 2.5 seconds; Interaction to Next Paint (INP), how quickly the page responds to a tap or click, which should be under 200 milliseconds; and Cumulative Layout Shift (CLS), how much the page jumps around while loading, which should be under 0.1. The report also lists what is causing the slowness, in order of impact, and that list is the fix list.

The usual causes are the same on almost every slow page: images that are too large, a stylesheet or script that blocks the page from rendering, a web font that arrives late, or a third-party widget — a chat box, a social feed, an ad — that loads before the content. Fix them in the order PageSpeed Insights lists them, because it sorts by impact: the top item is the biggest win, and fixing the fifth item first is a waste of an afternoon. One caution: do not chase a perfect score. A page that scores 90 on mobile with content that answers the query beats a page that scores 100 with content that does not. Speed is a tie-breaker between two good pages, not a substitute for a good page.

Pass: LCP under 2.5 seconds, INP under 200 milliseconds, CLS under 0.1 on mobile. Fail: any of the three over its threshold on mobile. Fix: work down the PageSpeed Insights opportunity list in order — images first, then render-blocking resources, then fonts and third-party widgets.

Check 17: Mobile viewport and tap targets

More than half of all web traffic is on a phone, and Google indexes the mobile version of a page first, so a page that works on a desktop and breaks on a phone is a page that is broken where it counts. The check starts with the viewport meta tag in the head: <meta name="viewport" content="width=device-width, initial-scale=1.0">. Without it, a phone browser lays the page out at desktop width and shrinks it to fit, and the text becomes unreadably small. With it, the page lays out at the phone’s real width. View the source and confirm the tag is there, exactly as written — a maximum-scale=1.0 or user-scalable=no added to it blocks pinch-zooming, which is an accessibility failure as well as a usability one.

Then test the page at phone width. Open developer tools, switch to a phone-sized viewport, and scroll through the whole page. Three things fail most often: text that runs off the right edge and forces horizontal scrolling, usually a code block or a table that is too wide; tap targets that are too small or too close together — links and buttons need to be at least 48 pixels apart and large enough to tap without hitting the neighbour; and a navigation menu that overlaps the content when it opens. Also check that nothing on the page requires hovering: a phone has no hover, so a menu or tooltip that only appears on hover is invisible to half your readers.

Pass: the viewport tag is correct, the page fits its width at 360 pixels with no horizontal scrolling, and every link and button is tappable without hitting its neighbour. Fail: missing or restrictive viewport tag, horizontal scrolling, or cramped tap targets. Fix: add the viewport tag, wrap wide code blocks and tables in a scrolling container, and space out the tap targets.

Check 18: Layout shift — does the page jump while it loads?

Layout shift is the page moving under the reader’s finger: text that jumps down when an image finally loads, a button that slides sideways when a font arrives, a banner that pushes the article down a second after the reader started reading. It is measured as Cumulative Layout Shift, and the audit wants it under 0.1, but the human test is simpler — load the page on a slow connection and watch it. If anything moves after it first appears, that is a shift, and it is a fail even if the number comes out just under the threshold.

The cause is almost always the same: the browser did not know how much space to reserve for something that had not loaded yet. The fix is to tell it. Images and videos need width and height attributes, so the browser reserves exactly the right rectangle before the file arrives. Advertisements and embedded widgets need a container with a fixed minimum height. Web fonts need a fallback font with similar metrics, so the text does not reflow when the real font arrives — or the font should be loaded with font-display: swap so the fallback shows immediately and the swap, when it comes, is a change of shape rather than a change of layout. A page with no images, no ads, and system fonts rarely shifts at all; a page with five un-sized images and two ads will shift on every load.

<!-- PASS: dimensions declared, so the browser reserves the space before loading -->
<img src="heading-levels-800.webp" alt="Diagram of HTML heading levels from H1 to H6" width="800" height="450">

<!-- FAIL: no dimensions — the page jumps when this image loads -->
<img src="heading-levels-800.webp" alt="Diagram of HTML heading levels from H1 to H6">

Pass: CLS under 0.1, and nothing visibly moves while the page loads. Fail: CLS over 0.1, or any visible jump. Fix: add width and height to every image and video, reserve space for ads and embeds, and use font-display: swap on web fonts.

Group G — Structured Data and Social Sharing

Check 19: Structured data — schema markup the page carries

Structured data is a small block of code, usually JSON-LD in the head, that tells a search engine what the page is in machine-readable terms: this is an article, written by this author, published on this date. It is what earns the extras in a search result — the star rating, the publication date, the breadcrumb trail, the FAQ dropdown. The check is to view the source and look for a <script type="application/ld+json"> block, then validate it. Google’s Rich Results Test will read the URL and report exactly which rich results the page is eligible for, and whether the markup has errors. The W3C validator will not check JSON-LD, so this is a separate test, and it is one auditors often skip — which is why broken schema is one of the commonest audit findings.

Two failures dominate. The first is schema that describes a different page: an Article block copied from another post, with the wrong headline, the wrong date, or the wrong URL. A search engine that finds the headline in the schema disagreeing with the headline on the page trusts neither. The second is schema that promises something the page does not deliver — a Review block with a rating the page never shows, or a FAQ block whose questions do not appear on the page. Google treats that as misleading markup, and a page caught doing it can lose its rich results entirely. The rule is that the schema must describe what is actually on the page, nothing more. For an article page, an Article block with the headline, author, publisher, and dates is the right amount; add a FAQ block only if the page genuinely carries a FAQ section.

<!-- PASS: Article schema that matches the page it sits on -->
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "HTML Meta Tags: Complete SEO List Every Page Needs 2026",
  "author": { "@type": "Person", "name": "Ahmed Haseeb" },
  "datePublished": "2026-10-31",
  "dateModified": "2026-11-21",
  "mainEntityOfPage": "https://allabouthtml.com/html-meta-tags-seo/"
}
</script>

Pass: a valid JSON-LD block that matches the page’s headline, dates, and URL, confirmed in the Rich Results Test. Fail: missing schema, invalid JSON, or schema that disagrees with the page. Fix: generate the block from the page’s real data — most SEO plugins do this automatically — and validate it before publishing.

Check 20: Open Graph and Twitter cards — how the page looks when shared

The last check is the one nobody sees until it is too late: what the page looks like when someone shares its link. A page shared on Facebook, X, LinkedIn, or WhatsApp shows a card — a title, a description, and an image — built from Open Graph tags in the head. If those tags are missing, the platform guesses, and its guess is usually the wrong image, a truncated title, or the site’s generic description. The check is to view the source and look for og:title, og:description, og:image, and og:url, plus twitter:card with the value summary_large_image. Then test the result: Facebook’s Sharing Debugger and X’s Card Validator both fetch the URL and show the card exactly as it will appear.

The image is the part that fails most often. The Open Graph image should be 1200 by 630 pixels, under a few hundred kilobytes, and it should be an image that represents this page — not the site logo, and not a random photo from the article. A logo on a shared card tells the reader nothing about the article; a page-specific image with the article’s topic earns the click. The title and description in the Open Graph tags should match the page’s real title and description, not a shorter or catchier version written for social media — a card that promises one thing and delivers another is the same disappointment as a misleading search result, and it costs the click twice over, because the person who shared it looks careless too.

<!-- PASS: complete Open Graph set, page-specific image at 1200x630 -->
<meta property="og:title" content="HTML Meta Tags: Complete SEO List Every Page Needs 2026">
<meta property="og:description" content="Learn HTML meta tags with working examples, a complete 2026 checklist, and copy-paste code for beginners.">
<meta property="og:image" content="https://allabouthtml.com/images/html-meta-tags-og.jpg">
<meta property="og:url" content="https://allabouthtml.com/html-meta-tags-seo/">
<meta property="og:type" content="article">
<meta name="twitter:card" content="summary_large_image">

Pass: og:title, og:description, og:image (1200×630, page-specific), and og:url all present and matching the page, confirmed in a sharing debugger. Fail: missing tags, a logo as the share image, or a card that shows the wrong title. Fix: set the tags in the SEO plugin with a page-specific image, and re-scrape the URL in the debugger after fixing.

A Reusable Audit Template: Your Own HTML Checklist Page

The best way to use this guide is to turn it into a tool. The document below is a complete, working audit sheet: save it as seo-audit.html, open it in any browser, type the URL of the page you are auditing at the top, and tick each check as you work through it. The page needs no server, no JavaScript framework, and no build step — it is plain HTML and a small internal stylesheet, and it prints cleanly, so you can keep a paper copy of each audit in a folder. Every check is a checkbox with the pass condition beside it, grouped exactly as in this guide, and the notes field at the bottom is where the fixes go.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>SEO Audit Checklist — One Page</title>
  <meta name="description" content="A reusable one-page SEO audit checklist: 20 HTML checks for any web page, with pass conditions and a notes field for fixes.">
  <style>
    body { font-family: system-ui, sans-serif; max-width: 760px; margin: 0 auto; padding: 24px; line-height: 1.6; color: #1a1a1a; }
    h1 { font-size: 1.6rem; }
    h2 { font-size: 1.2rem; margin-top: 2rem; border-bottom: 2px solid #c0392b; padding-bottom: 4px; }
    label { display: block; margin: 10px 0; }
    input[type="checkbox"] { width: 18px; height: 18px; margin-right: 8px; }
    input[type="text"], textarea { width: 100%; padding: 8px; font: inherit; margin: 6px 0 16px; }
    textarea { min-height: 120px; }
    @media print { body { max-width: none; } input[type="text"], textarea { border: 1px solid #999; } }
  </style>
</head>
<body>
  <h1>SEO Audit Checklist — One Page</h1>
  <p>Audit one page at a time. Tick a check only when it passes; anything unticked is a fix to write down below.</p>

  <label>Page URL: <input type="text" placeholder="https://example.com/page/"></label>
  <label>Auditor: <input type="text" placeholder="Your name"></label>
  <label>Date: <input type="text" placeholder="2026-11-21"></label>

  <h2>A. Indexing</h2>
  <label><input type="checkbox"> 1. Page is indexed (site: search or Search Console)</label>
  <label><input type="checkbox"> 2. No noindex tag; robots.txt does not block the page</label>
  <label><input type="checkbox"> 3. Canonical tag present and self-referencing</label>
  <label><input type="checkbox"> 4. Short readable URL, listed in the XML sitemap</label>

  <h2>B. Titles, meta & headings</h2>
  <label><input type="checkbox"> 5. Unique title tag, 50–60 characters, topic first</label>
  <label><input type="checkbox"> 6. Unique meta description, 120–155 characters</label>
  <label><input type="checkbox"> 7. Exactly one H1, the article's main heading</label>
  <label><input type="checkbox"> 8. Headings in order (H1 → H2 → H3), no level skipped</label>

  <h2>C. Content</h2>
  <label><input type="checkbox"> 9. Page matches the search intent of its target query</label>
  <label><input type="checkbox"> 10. Content is original and deep enough for the query</label>
  <label><input type="checkbox"> 11. Dates, versions, and code examples are current</label>

  <h2>D. Links</h2>
  <label><input type="checkbox"> 12. Three or more descriptive internal links; page is linked from a hub</label>
  <label><input type="checkbox"> 13. No broken links; external links use rel="noopener"</label>

  <h2>E. Images & media</h2>
  <label><input type="checkbox"> 14. Every content image has a specific alt attribute</label>
  <label><input type="checkbox"> 15. Images sized to display, right format, srcset where needed</label>

  <h2>F. Speed, mobile & layout</h2>
  <label><input type="checkbox"> 16. Core Web Vitals pass on mobile (LCP, INP, CLS)</label>
  <label><input type="checkbox"> 17. Correct viewport tag; no horizontal scroll at 360px; tappable targets</label>
  <label><input type="checkbox"> 18. No layout shift; images and videos carry width and height</label>

  <h2>G. Structured data & social</h2>
  <label><input type="checkbox"> 19. Valid JSON-LD schema matching the page (Rich Results Test)</label>
  <label><input type="checkbox"> 20. Open Graph tags complete; share image is 1200×630 and page-specific</label>

  <h2>Fixes — in audit order</h2>
  <textarea placeholder="1. …
2. …
3. …"></textarea>
  <p><strong>Score:</strong> ____ / 20  ·  <strong>Verdict:</strong> ____________________</p>
</body>
</html>

Use one copy per page, and keep the copies. After ten audits you will have a record of which failures your site repeats — the same missing alt text on every post, the same duplicated title on every category page — and those patterns are the real findings of an audit programme. A single page’s failures are a to-do list; a repeated failure across ten pages is a template bug, and fixing the template fixes ten pages at once. That is the moment an audit stops being a chore and starts being the highest-leverage work on the site.

How to Score the Page and What to Fix First

Count the passes. A page that passes 18 or more of the 20 is in good shape: fix the two failures and move on. A page that passes 14 to 17 has real work to do, but nothing structural — usually a cluster of small failures in one group, such as every image missing alt text, or every link using “click here”. A page that passes fewer than 14 has a structural problem, and the fix order matters more than the fix count: start with Group A, because an unindexed page is invisible whatever else is wrong with it, then Group B, because a page with the wrong title and no H1 cannot rank for its topic, then the group with the most failures.

Fix in audit order, and fix one group completely before starting the next. The reason is not tidiness; it is measurement. If you change the title, the headings, and the images all in the same afternoon, and the page’s traffic rises a month later, you will not know which change caused it. If you change one group, wait two to four weeks, and check Search Console, you will know. That knowledge compounds: after a few pages you will know which fixes move the needle on your site and which ones do not, and your audits will get faster because you will know what to look for first.

One last rule: re-audit after fixing. A fix that was never verified is a guess, not a fix. Run the same 20 checks again, tick the boxes, and record the new score beside the old one. The second audit takes half the time of the first, because you already know the page, and it is the only way to catch the fix that introduced a new problem — the rewritten title that is now 72 characters long, the resized image that lost its alt text, the canonical tag that now points at the staging URL.

Free Tools for Every Check

ToolWhat it checksCostLimitation
Browser developer tools (F12)Headings, images, links, console errors, mobile layoutFree, built inOne page at a time, manual
View-source (view-source:)The HTML exactly as the server sent itFree, built inNo JavaScript-rendered content
W3C validator (validator.w3.org)HTML errors, deprecated attributes, code examplesFreeDoes not check JSON-LD schema
PageSpeed Insights (pagespeed.web.dev)Core Web Vitals, speed opportunities, mobile scoreFreeLab data can differ from real users
Google Search ConsoleIndexing status, crawl errors, impressions, queriesFreeNeeds site ownership verification
Google Rich Results TestJSON-LD validity and rich-result eligibilityFreeOne URL at a time
Facebook Sharing DebuggerOpen Graph card previewFreeNeeds a public URL
Screaming Frog (free tier)Whole-site crawl: titles, links, images, status codesFree up to 500 URLsDesktop app, learning curve

Paid tools — Ahrefs, Semrush, Sitebulb — automate these same checks across hundreds of pages and add competitor comparison. They are worth it when you audit whole sites every week. For one page, or ten pages a month, the free tools above check exactly the same things, and the manual method teaches you the page in a way a report never will.

Frequently Asked Questions

1. How long does an SEO audit take?

About an hour for your first audit of a page, and about thirty minutes once you have done a few. A whole-site audit takes longer in proportion to the number of pages, but the method is the same: audit the ten most important pages properly, and the site-wide picture assembles itself. Do not try to audit every page of a large site in one sitting — you will burn out at page twelve and fix nothing. One page a day, done properly, beats a hundred pages skimmed in a weekend.

2. How often should I audit a page?

Audit a page when something changes: when it is first published, when its traffic drops, when you rewrite it, and once a year as routine maintenance. A page that has not changed and whose traffic is steady does not need auditing — the search results around it change, but a yearly check is enough to catch that. What needs auditing on a schedule is the site’s template: every time the template changes, re-audit one page built on it, because a template bug repeats on every page it builds.

3. Do I need a paid SEO tool to do an audit?

No. Every check in this guide can be done with free tools: browser developer tools, view-source, the W3C validator, PageSpeed Insights, Search Console, and the Rich Results Test. Paid tools automate the same checks across many pages and add competitor data, which is valuable when you audit whole sites every week. For one page, the manual method is faster, cheaper, and teaches you the page. Buy a paid tool when the manual method costs you more time than the subscription costs money — not before.

4. Will fixing everything in an audit make my page rank first?

No, and any tool or consultant who promises that is selling something. An audit removes the things holding a page back; it does not add the things that make a page win — the depth of the content, the quality of the answer, the authority of the site, and the strength of the competition. A page that passes all 20 checks and still sits on page two has a content problem or a competition problem, and the audit has done its job by telling you that the problem is not in the HTML.

5. What is the single most important check in an SEO audit?

Check 1: is the page indexed? Everything else in the audit assumes the answer is yes, and nothing else matters if it is no. After that, check 5 — the title tag — is the highest-value single fix on most pages, because it is the first thing a searcher sees and the strongest single signal of what the page is about. If you have five minutes and one page, check those two, and you will have found the problem on most of the pages that have one.

Conclusion

An SEO audit is not a score, a report, or a redesign. It is twenty questions asked in order, each with a pass condition and a fix, worked through with free tools and written down on a sheet. The order matters: indexing before titles, titles before content, content before links, and everything before performance, because a fix applied out of order is a fix wasted. The sheet matters too: an audit whose findings were never written down is an afternoon spent reading HTML, not an audit.

Start with one page — the page that matters most to you, or the one whose traffic has been falling. Work through the twenty checks, write down every fail and its fix, and then fix them in audit order, one group at a time. Re-audit when you are done, and record the new score beside the old one. Then do the next page. After ten pages you will stop finding surprises, because the same failures will keep appearing, and when they do, you will have found the real prize of an audit programme: not a list of fixes, but the template bug, the publishing habit, or the missing step in the checklist that caused them all. Fix that, and ten pages get better at once. That is what an SEO audit is for.

Related Articles You’ll Love

Exit mobile version