
· 16 min read
What is SEO? How it works, tested on 20 real sites
We ran a 251-rule audit on 20 well-known homepages: none scored 100 and the median site failed 13 rules. Learn what SEO is, how it works, and audit yours.
We re-requested 549 top homepages: 86.7% honored If-Modified-Since, only 58.1% If-None-Match. How Last-Modified and ETag work, and which one Google uses.
Oğuzhan Ulukaya · Software Developer, SEOmator
Full-stack TypeScript developer building B2B SaaS products since 2021

How we know this
Full method ↓The Last-Modified header is the date a server says a page last changed. A browser or crawler sends that date back in an If-Modified-Since header, and if nothing has changed, the server answers 304 Not Modified with no body. When we tested the Tranco top 1,000 sites on 31 October 2026, 86.7% of the homepages that sent Last-Modified honored it.
The gap between those two numbers is the part most guides skip. Google's crawling documentation says that when a response carries both an ETag and a Last-Modified date, its crawlers use the ETag, and it recommends ETag because it "doesn't have date formatting issues." So a server that handles dates well but fumbles ETags is broken on exactly the route Google prefers.
I build B2B SaaS products in TypeScript and Next.js, and from the developer's side this is where caching quietly breaks. A self-hosted Next.js app, for example, hashes the HTML it is about to send into the ETag. One per-request value in that HTML, a timestamp or a CSP nonce, gives every response a new ETag, and no conditional request can ever match. Nothing errors. The crawler downloads the whole page again.

Efficient cache headers reduce redundant data transfers between servers and crawlers
These two HTTP headers work as a pair. Think of them as a conversation between your browser (or Googlebot) and your server. The If-Modified-Since header is the question: "Has this page changed since this date?" The Last-Modified header is the answer the server gave earlier: "Here's when I last updated this resource."
When implemented correctly, this exchange eliminates unnecessary data transfers. Instead of downloading a full page every time, the server can simply respond with a 304 status code that says "Nothing's changed, use your cached version."
The technical breakdown:
ETag and If-None-Match are the second validator pair and do the same job with an identifier instead of a date. The server sends an opaque ETag such as "34aa387-d-1568eb00" (usually a hash or version number), the client sends it back in If-None-Match, and a match earns a 304. RFC 9110, the HTTP standard, tells a server to ignore If-Modified-Since whenever If-None-Match is present, because an entity tag is the more accurate check.
The date itself has a strict format. Google's documentation recommends the HTTP-date form, for example Fri, 4 Sep 1998 19:15:56 GMT: weekday, day, month, year, time, and always GMT. A local time zone or an ISO 8601 date is the kind of "date formatting issue" that makes Google prefer ETags.
Here's exactly what happens during a conditional GET request. This is the mechanism that makes If-Modified-Since so useful for SEO.
When a browser or Googlebot first visits your page, they send a standard HTTP request. Your server responds with the full page content, a 200 status code, and, importantly, a Last-Modified header (often an ETag as well):
Last-Modified: Thu, 15 Jan 2026 14:30:00 GMT
On the next visit, the browser includes an If-Modified-Since header with that stored timestamp:
If-Modified-Since: Thu, 15 Jan 2026 14:30:00 GMT
Your server compares timestamps and makes a decision:
This might seem like a minor optimization, but when you're dealing with thousands of pages and regular crawling, the cumulative effect is substantial.
Most top homepages don't answer a conditional request with a 304. On 31 October 2026 we requested the homepages of the Tranco top 1,000 domains. 549 answered with an HTML page (the rest were API and CDN hostnames with no homepage, errors, or bot walls). Then we replayed each validator they sent and recorded the answer.
| What the homepage sent | Homepages | Share of 549 | Replayed in | Answered 304 |
|---|---|---|---|---|
| Last-Modified | 180 | 32.8% | If-Modified-Since | 86.7% |
| ETag | 180 | 32.8% | If-None-Match | 58.1% |
| Both | 92 | 16.8% | Both headers together | 88.0% |
| At least one validator | 268 | 48.8% | Either | 76.1% |
| Neither | 281 | 51.2% | Nothing to replay | 0% |
Those 47 are the clearest failures: the server says the version hasn't changed and sends the whole page anyway. The 28 are a different problem. Their ETag changes between requests seconds apart, and 15.6% of all homepage ETags changed between two plain requests in our test, against 3.3% of Last-Modified dates.
The date route held up far better. Only 3.9% of the Last-Modified dates we saw were within two seconds of the response's own Date header, the "timestamp is always now" mistake.
The 51.2% of homepages with no validator at all stands out against the 2021 Web Almanac, where only 24.5% of all responses carried neither. The Almanac counted images, scripts and stylesheets too, files a web server sends with validators attached by default; HTML built per request often gets none.
Sitemaps did better than homepages. Of 287 /sitemap.xml files that answered, 66.6% sent a validator and 54.4% returned a 304 to at least one conditional request. The same split showed up: 86.4% honored If-Modified-Since, 62.1% If-None-Match. If you're not sure where a site keeps its sitemap, here's how to find a site's sitemap.
We ran the same check on our own pages that day. seomator.com and this post send a weak ETag and no Last-Modified, and a replayed ETag gets a 304. Google suggests setting both validators, so the missing date is on our list too.
We took the top 1,000 domains of Tranco list 746VX (generated 30 October 2026), the same approach as our robots.txt study, and ran a Node.js script from Istanbul on 31 October 2026 with a desktop Chrome user agent. For each domain it:
https://<domain>/ (falling back to www.) and kept it only if the final answer was a 200 HTML page./sitemap.xml when it returned a <urlset> or <sitemapindex>.A 200 that carried the same validator we sent counts as "ignored"; a 200 with a different validator counts as "changed." 87 domains blocked the request (401, 403, 429, 503 or a bot challenge) and 364 had no usable homepage, so the shares above are of the 549 that answered.
The limits matter. This is one location and a browser user agent, not Googlebot, and CDNs can treat crawlers differently. Our website crawl test fetches a page with Googlebot's user agent if you want to see what your server returns to it. It covers homepages and sitemaps, not article templates. The script and raw results are kept so we can rerun it and compare.
Google has been increasingly transparent about crawl budget constraints, and explicit about who should worry. Its crawl budget guide is written for sites with more than a million unique pages that change weekly, or more than 10,000 that change daily. Below that, crawl budget is rarely the bottleneck, though the bandwidth and server savings still apply.
Your site has a limited crawl budget, the number of pages Googlebot will crawl within a given timeframe. When unchanged pages return 304 responses instead of full content, Googlebot can allocate more resources to crawling your new and updated content.
Google's own wording: "If a page hasn't changed since Google last crawled it, returning a 304 code tells Google to reuse the cached version, saving your server bandwidth and resources."
Returning a 304 response is faster than generating and sending full page content, but by less than you'd think once the connection is open. On the 204 homepages that answered a conditional request with a 304, the median warm 200 took 114 ms from Istanbul and the median 304 took 73 ms, a median saving of 25 ms per request. The bigger win is on your side of the wire: the server can skip rendering the page at all if it can check the validator cheaply.
For high-traffic sites, bandwidth costs add up. The median homepage in that group was 141.6 KB of HTML after decompression, and a 304 sends none of it. Multiply that by every bot and returning browser that revalidates, and the saving is in bytes and CPU more than in milliseconds. AI crawlers now add to that bot traffic; our monthly AI crawler report tracks which ones crawl the most.
Faster page loads mean better experiences for returning visitors: a browser that already holds a page and gets a 304 can show it without downloading it again. Keep the ranking claim in proportion: Google's page experience documentation says Core Web Vitals are used by its ranking systems, but a 304 does nothing for a first visit, and good scores don't guarantee top rankings. For the wider picture, see how page load speed affects rankings and engagement.
Google uses the ETag when both are present, and recommends sending both anyway. The two validators differ in ways that matter on a real server:
| Last-Modified / If-Modified-Since | ETag / If-None-Match | |
|---|---|---|
| What it compares | A date, to the second | An opaque string chosen by the server |
| Google's crawlers | Supported | Supported, and used when both are present |
| Most common failure | Wrong date format, or "now" on every request | A new value on every request, or a suffix added by compression |
| Precedence (RFC 9110) | Ignored when If-None-Match is present | Evaluated first |
| Honored by homepages we tested | 86.7% | 58.1% |
Weak ETags (prefixed W/) are fine for this. RFC 9110 has If-None-Match use the weak comparison, so W/"abc" still matches. 53.3% of the homepage ETags in our test were weak.
Here are the problems we saw most frequently in our test:
Some servers and CMS platforms don't send Last-Modified headers by default. Without this header (or an ETag), browsers and crawlers can't make conditional requests, and every visit downloads the full content. That was 51.2% of the homepages we tested.
How to check: Use browser DevTools (Network tab) or an HTTP header checker to see whether your pages return Last-Modified or ETag headers. The verification steps below show how.
Setting Last-Modified to the current server time on every request defeats the purpose entirely. The timestamp must reflect when the actual content was last changed, not when it was last requested. RFC 9110 also forbids a Last-Modified date later than the response's Date header.
This is the ETag version of the same mistake, and it was more common: 15.6% of the homepage ETags we saw changed between two identical requests. Frameworks that hash the rendered HTML (Next.js does this by default with generateEtags) produce a new ETag whenever the HTML carries a per-request value. Build the ETag from the content or its version, not from the response.
-gzip to the ETag of compressed responses, and Apache's documentation says this "prevents serving 'HTTP Not Modified' (304) responses to conditional requests for compressed content." 16 homepages in our test had an ETag ending in a compression suffix like -gzip, and only 4 of them answered If-None-Match with a 304.Most of the rest, among them ibm.com, hp.com and avast.com, answered a replayed date with 304 and a replayed ETag with the full page. On Apache 2.4.58 or later, the DeflateAlterETag directive fixes this (see the Apache section below).
Pages with dynamic elements (user-specific content, real-time data) need careful handling. The Last-Modified header should reflect the most recent modification time among all component parts, not just the template.
Cache-Control: no-cache as "don't cache." RFC 9111 defines it as "store it, but revalidate before every reuse," so a 304 lets the browser use its stored copy. To forbid storage, the directive is no-store.If you're sending Cache-Control: no-cache alongside Last-Modified headers, browsers will still validate with the server, and when it answers 304 they use the cached copy. Make sure your cache directives align with your validation strategy. no-cache plus a working validator is a sensible default for HTML: every visit checks with the server, and unchanged pages cost a 304. Google adds that a max-age on Cache-Control can help its crawlers decide when to recrawl, and that other caching directives aren't supported by its crawlers.
WordPress sites benefit from cache plugins that handle these headers, but the plugins differ more on validators than their feature lists suggest. Here's what three popular ones do, checked in their source on 31 October 2026:
.htaccess removes ETags on Apache (Header unset ETag and FileETag None), so cached pages rely on Last-Modified.WordPress also offers dedicated Last-Modified plugins if you want granular control without a full caching solution.
For static files, Apache sends Last-Modified on its own and builds the ETag from the file attributes listed in FileETag. For Apache servers, add these directives to your .htaccess file or server configuration.
The first line keeps the default ETag recipe (modification time and size); the block below it tells caches to revalidate with the server once the hour is up.
FileETag MTime Size
<IfModule mod_headers.c>
Header set Cache-Control "public, max-age=3600, must-revalidate"
</IfModule>
If you compress with mod_deflate on Apache 2.4.58 or later, also fix the ETag suffix. DeflateAlterETag works only in the server or virtual host configuration, not in .htaccess:
DeflateAlterETag Remove
Remove drops the ETag from compressed responses, so Last-Modified takes over. NoChange keeps one ETag for both encodings instead, which Apache's documentation notes breaks the rule that every representation has its own ETag. Pages your application generates (PHP, Python, Node) still need the application to set a validator and answer the conditional request.
Nginx handles Last-Modified headers automatically for static files. For dynamic content, configure your application to set appropriate timestamps:
location / {
add_header Cache-Control "public, max-age=3600";
# Both are on by default and apply to files Nginx serves itself
etag on;
if_modified_since exact;
}
According to the Nginx documentation, etag covers static resources. exact means a 304 only when the date matches the file's modification time exactly, which is what browsers and crawlers send back.
Don't assume your headers are working. Verify them. Here's the testing workflow:
These curl commands cover steps 1 and 2. The first shows which validators the page sends; the other two replay them one at a time (paste your own values):
curl -sI --compressed https://example.com/ | grep -iE '^(etag|last-modified|cache-control)'
curl -s -o /dev/null -w '%{http_code}\n' --compressed -H 'If-None-Match: "abc123"' https://example.com/
curl -s -o /dev/null -w '%{http_code}\n' --compressed -H 'If-Modified-Since: Thu, 15 Jan 2026 14:30:00 GMT' https://example.com/
--compressed in all three commands. Without it, curl asks for an uncompressed page, and a server with the Apache -gzip problem will pass the test while still failing every browser and crawler that accepts gzip.A properly configured page should respond like this to a conditional request:
HTTP/1.1 304 Not Modified
Date: Thu, 29 Jan 2026 10:00:00 GMT
ETag: "abc123"
Cache-Control: public, max-age=3600
RFC 9110 requires a 304 to repeat the headers a 200 would have carried, such as Date, ETag, Cache-Control and Vary.
Expect the change to show up in your logs and Crawl Stats, not as a ranking jump. Google describes the effect as saved bandwidth and resources, plus the chance to read more of your site if pages load faster; it doesn't promise ranking gains. In our test, each 304 saved a median 141.6 KB of HTML and 25 ms against a warm 200 (homepages, 31 October 2026).
Sites big enough to have a crawl budget problem see the most. For a sense of where crawler requests go to waste, our crawl waste report breaks requests down by status code.
Implementing If-Modified-Since and Last-Modified headers correctly is one of the cheaper technical SEO fixes you can make. Here's what to remember:
Whether you implement this manually or use a caching plugin, don't skip this optimization. The time investment is minimal, but the impact on your site's crawlability and performance can be substantial.
Run your own templates through the header checker, then replay the validators with the curl commands above. If both requests come back 304 with compression on, crawlers and browsers can stop re-downloading pages that haven't changed.
Last-Modified is an HTTP response header that tells the client the date and time the server believes the resource last changed, in the format Thu, 15 Jan 2026 14:30:00 GMT. Browsers and crawlers send it back in If-Modified-Since so the server can answer 304 Not Modified instead of resending the page.
If-Modified-Since sends back a date, If-None-Match sends back an ETag. RFC 9110 tells servers to ignore If-Modified-Since when If-None-Match is present. In our October 2026 test, homepages honored the date 86.7% of the time and the ETag 58.1% of the time.
Use both. Google recommends ETag for its crawlers because it has no date-format problems, and it uses the ETag when both are present, but its documentation also suggests setting both because other software reads them. Then test that both return 304.
Googlebot supports caching when it recrawls URLs for Google Search and sends the validators it saved: If-None-Match for an ETag, If-Modified-Since for a date. Not every Google crawler does; Google's documentation says Storebot-Google caches only in certain conditions.
No. Search Console lists Not modified (304) among the good response codes, and Google's crawl budget guide asks sites to support it. A 304 tells Google to reuse the copy it already has.
The Last-Modified header is one clue, but many sites don't send it (67.2% of the homepages we tested didn't), and some set it to the current time. The browser's document.lastModified reads the same header and, when there is none, returns the current date and time, so it isn't proof either. Here are other ways to check when a website was last updated, from sitemaps and structured data to the Internet Archive.
Who wrote it, what changed and how to tell us about a mistake.

Oğuzhan Ulukaya
Software Developer, SEOmator
Full-stack TypeScript developer building B2B SaaS products since 2021
Oğuzhan Ulukaya is a software developer at SEOmator, which he joined in September 2026. He is a product-focused full-stack developer who works in TypeScript, with React and Next.js on the front end, and his recent work puts vector databases and AI features into production.
Oğuzhan has built B2B SaaS products since 2021. Based in İzmir, Türkiye, he has worked at Next Yazılım Teknoloji on Popupsmart since 2022, on the AI customer support tool LiveChatAI since 2023 and on QRCodeDynamic since 2026, after starting out as a frontend developer at Saypr. He holds a BSc in Computer Science from Dokuz Eylül University.
Rebuilt on a new test of the Tranco top 1,000 sites (549 homepages, 287 sitemaps). Added how Google uses ETag and Last-Modified; removed figures and case results we couldn't verify; corrected the no-cache, Apache, Nginx and WordPress plugin advice.Written by Oğuzhan Ulukaya
Published.Written by Nick Sawinyh
Spot a mistake or a number that has gone stale? Tell us. We correct it and log the change in the History above. Report an error →
SEOmator Rank Tracker
Technical fixes are invisible until positions move. Track the keywords a fix was meant to affect and watch whether it actually landed.
SEOmator Rank Tracker
· 16 min read
We ran a 251-rule audit on 20 well-known homepages: none scored 100 and the median site failed 13 rules. Learn what SEO is, how it works, and audit yours.

· 7 min read
Imagine you're an artist. Would you be happy to find your artwork showcased in someone else's gallery without your consent, where no one can place you as the legitimate painter?

· 22 min read
We tested 151 B2B SaaS pricing pages from Google's page 1. Rendering and canonicals are mostly fine; only 32.5% mark up prices. The 8-step audit.