DEV Community: Eduard

How to Actually Raise Your Google PageSpeed Score in 2026

Eduard — Wed, 05 Aug 2026 01:45:27 +0000

A few weeks ago I finished a three-hour deep dive into font loading for a client. Subsetting, preloading, font-display: swap — the works. PageSpeed came back at 92.
The client asked the only question that mattered: “Did we fix the real problem?”

The hero image was still 4.2 MB. One conversion to AVIF and a proper <picture> tag later the score dropped to 58. Suddenly Lighthouse could see everything else that was broken.

That’s the thing about PageSpeed scores. They show you what the lab thinks is slow. Real users often experience something completely different.

What PageSpeed Insights Really Measures
Real Case Study: 42 → 91 in One Afternoon
The Five Things That Move the Needle Most
When the Score Lies
My Real Workflow (Not a Checklist)
The WebP (and AVIF) Trap + Code Example
Fonts That Don’t Block the Page
Why INP Matters More Than the Old FID
The Real 80/20
When to Stop
Quick Checks Before the Next Test
Bottom Line
Related Guides
Sources & Further Reading

What PageSpeed Insights Really Measures

Google PageSpeed Insights runs Lighthouse in a controlled lab. You get a 0–100 number. That number itself is not a ranking factor. Core Web Vitals are. And the two are related, but not identical.

Here’s the simple rule I give clients:

Below 50 → real problems that users feel
50–89 → fix the obvious stuff
90+ → open Chrome DevTools and look at actual load time before you celebrate

For a deeper look at the ranking metrics that actually matter, see our guide on how to fix Core Web Vitals issues.

Real Case Study: 42 → 91 in One Afternoon

Last month a mid-size e-commerce client came in with a mobile PageSpeed score of 42. Field data from CrUX showed LCP at 4.1 s and INP at 380 ms. Users were bouncing hard on product pages.
We did two things only:

Converted the 3.8 MB hero JPEG to AVIF (primary) + WebP (fallback) and served it with a proper <picture> element.
Removed or deferred 1.2 MB of third-party trackers and chat widgets that were blocking the main thread.

Results after one afternoon of work:

Metric	Before	After
Mobile PageSpeed	42	91
LCP	4.1 s	1.3 s
INP	380 ms	95 ms
Total page weight	6.4 MB	1.9 MB

No fancy critical CSS, no server migration, no CDN change. Just images and JavaScript hygiene. That’s why I keep saying the big wins are almost always the boring ones.

Want to see where your own site stands right now? Open the free SEO analyzer in another tab and run your URL while you keep reading.

The Five Things That Move the Needle Most

After looking at more than two hundred sites, the same five issues keep showing up.

Images. Almost always the biggest culprit. I have yet to audit a site under 70 where images weren’t the main drag. Full details in our Image SEO complete guide.

JavaScript execution time. This one hides. You can score 95 and still have three seconds of main-thread blocking. Check the Performance panel, not just the Lighthouse report. Slow JS is also the primary reason INP fails on mobile.

Server response time (TTFB). If the server takes more than 800 ms to answer, nothing else you do will feel fast.
Caching. Set it once and every return visitor benefits.
CDN. If your audience is spread across countries and your origin is in one place, a CDN is no longer optional.

When the Score Lies

Last quarter I checked a Shopify store that scored 98. Actual load time for a real user: 4.2 seconds. Forty-seven tracking scripts, a chat widget, a popup, and three recommendation engines. Lighthouse tested a clean version without most of that noise.
Lab data and field data are different animals. Real visitors have ad blockers, older phones, and flaky connections that no lab simulation fully captures.

My Real Workflow (Not a Checklist)

When someone asks me to improve their score, this is what I actually do.

Open DevTools first. Look at the network waterfall. Total size, number of requests, longest assets. Try it now: open Chrome DevTools on your own site, go to Network, disable cache, reload, and sort by size. If anything over 200 KB is an image or a third-party script, you already know your first target.
Find the biggest offenders. Usually images. Sometimes a 2 MB JavaScript bundle that does almost nothing useful.
Fix images. Convert to modern formats, add srcset, lazy-load everything below the fold. Fifteen minutes of work often gains 10–20 points.
Kill unused JavaScript. Open the Coverage tab. Sixty to eighty percent of the code is frequently never executed. Remove it.
Stop over-optimizing. Chasing the last three points on a 95 score is rarely worth the time. If you want a broader technical check after these steps, run a full SEO audit.

The WebP (and AVIF) Trap + Code Example

Everyone says “just convert to WebP.” I did that once and the score went down. Older Safari versions didn’t support it cleanly, and the fallback JPEG was three times larger.
Now I always use the full <picture> element with multiple sources and a solid fallback. More markup, but it works everywhere.

Here’s the exact pattern I ship:

<picture>
  <source
    srcset="hero-800.avif 800w, hero-1200.avif 1200w, hero-1600.avif 1600w"
    type="image/avif"
    sizes="(max-width: 768px) 100vw, 1200px">
  <source
    srcset="hero-800.webp 800w, hero-1200.webp 1200w, hero-1600.webp 1600w"
    type="image/webp"
    sizes="(max-width: 768px) 100vw, 1200px">
  <img
    src="hero-1200.jpg"
    width="1200"
    height="675"
    alt="Product hero showing the main benefit"
    fetchpriority="high"
    decoding="async">
</picture>

Key points:

AVIF first, WebP second, JPEG last.
Explicit width and height prevent CLS.
fetchpriority="high" on the LCP image.
Never put loading="lazy" on the hero.

For third-party scripts that are not needed on first paint, the same principle applies:

<!-- Bad: blocks parsing and execution -->
<script src="https://example.com/tracker.js"></script>
<!-- Better: does not block parsing -->
<script src="https://example.com/tracker.js" defer></script>
<!-- Best for non-critical widgets: load only after interaction or idle -->
<script>
  window.addEventListener('load', () => {
    const s = document.createElement('script');
    s.src = 'https://example.com/chat-widget.js';
    s.async = true;
    document.body.appendChild(s);
  });
</script>

Fonts That Don’t Block the Page

font-display: swap is not a magic bullet. It just means invisible text for a moment, then a flash. Fine for body copy. Ugly for headlines.
My current approach: system fonts for body text, and for brand fonts — preload only the exact weights you actually use. I still see sites loading twelve font files when they need three.

Why INP Matters More Than the Old FID

FID (First Input Delay) only measured the delay before the very first interaction. Google replaced it with INP (Interaction to Next Paint) in 2024, and by 2026 it is the only interactivity metric that counts for ranking.

INP looks at every interaction throughout the page life — clicks, taps, key presses — and reports the worst ones (98th percentile). That is why a site can have a perfect lab score and still feel laggy on a mid-range Android phone.
The main cause of poor INP is almost always JavaScript that monopolizes the main thread for longer than 50 ms. Long tasks from analytics, chat widgets, A/B testing libraries, or heavy event handlers are the usual suspects.

Practical ways to improve INP:

Break long tasks into chunks under 50 ms (setTimeout, requestIdleCallback, or the newer Scheduler API).
Defer or remove third-party scripts that run on every page load.
Use the Coverage tab and the Performance panel together — Coverage shows unused code, Performance shows the actual long tasks. If your INP is above 200 ms on mobile, fixing JavaScript will usually give a bigger ranking and conversion lift than shaving another 5 points off the PageSpeed score.

The Real 80/20

Three actions deliver most of the gain:

Compress and correctly size every image (Squoosh is still free and excellent).
Remove unused JavaScript with the Coverage tab.
Turn on caching and put a CDN in front of the site. On platforms like Vercel or Netlify this is already handled. Everything else — critical CSS, advanced preloading, Speculation Rules — is polishing. Do the big three first.

When to Stop

I once spent eight hours with a client trying to turn a 99 into a 100. The missing point was a 12 KB analytics script that was already async.
My rule now: if the score is above 90 and real load time is under two seconds, stop. Your time is more valuable than that last point.

Quick Checks Before the Next Test

Run the URL through a proper combined audit (PageSpeed + real traffic signals) at AuditMe.
Look at your largest image. Anything over 200 KB needs attention.
In DevTools → Network, disable cache and reload. If the page is over 2 MB, something is wrong.
Check the JavaScript bundle size. Over 500 KB usually means dead code.
For a focused score check, use the dedicated SEO Score Checker.
Want the full picture in under a minute? The free SEO analyzer pulls it all together. ## Bottom Line PageSpeed scores are useful signals, not the final truth. I have seen perfect 100s that felt sluggish and mid-60s that loaded faster than most sites. Focus on what users actually experience. Under two seconds, green Core Web Vitals (especially LCP under 2.5 s and INP under 200 ms) put you ahead of the majority of the web. That’s the only score that really matters.

Related Guides

Continue with these practical guides from the same series:

Complete SEO Audit Guide 2026: How to Find and Fix Every Issue — full 12-point checklist covering meta tags, schema, content, and more.
How to Fix Core Web Vitals Issues: LCP, INP, CLS Explained — deep dive into the three metrics that actually affect rankings.
Image SEO: Complete Guide to Optimizing Images for Search — formats, responsive images, alt text, and performance impact.

Sources & Further Reading

This article draws on practical audit experience and the following public resources:

Google PageSpeed Insights — official lab and field data tool.
Web Vitals documentation — Google’s definitions and thresholds for LCP, INP, and CLS.
Lighthouse scoring methodology — how the 0–100 score is calculated.
Optimize LCP and Optimize INP — official Chrome performance guides.
Squoosh — free image compression and format conversion tool referenced in the 80/20 section.
Internal site resources: AuditMe, SEO Score Checker, Free SEO Analyzer.

WordPress SEO Audit Checklist — 15 Things Worth Checking in 2026

Eduard — Sun, 02 Aug 2026 21:54:34 +0000

WordPress still powers about 43% of the web. That means your competition is not only other WordPress sites — it’s also headless setups, well-funded content teams, and stores that ship updates every week.
Most ranking drops I see on WordPress installs come from the same three places:

Plugin and theme conflicts that quietly break technical SEO
On-page issues that accumulate over months
Content that became thin or outdated while nobody was looking A focused 30–40 minute audit once a month (or at least once a quarter) catches most of this damage early. Here’s the exact checklist I use.

How to use this checklist
Technical SEO (5–8 minutes)
- 1. Permalink structure
- 2. XML Sitemap
- 3. robots.txt
- 4. Broken links (internal first)
- 5. HTTPS and mixed content
On-Page SEO (10–15 minutes)
- 6. Title tags
- 7. Meta descriptions
- 8. H1 tags
- 9. Heading hierarchy
- 10. Image alt text + performance
- 11. Internal links
- 12. Content length and quality
Schema, Social & Performance (5–10 minutes)
- 13. Structured data (Schema)
- 14. Open Graph and Twitter Cards
- 15. Core Web Vitals
Priority order after the audit
Useful free (or freemium) tools
Final notes
Similar useful articles
Sources & further reading

How to use this checklist

Do it in order. Technical issues first — they affect everything else.
Spend more time on your top 10–20 pages by traffic or revenue.
Write down every problem you find. Don’t try to fix everything in one sitting.
After the audit, prioritize: high impact + low effort first.
Re-check rankings and organic traffic 2–4 weeks later.

You don’t need expensive tools for the first pass. Browser, Search Console, PageSpeed Insights, and one free crawler are enough. If you want to speed things up, you can also run a quick automated check with a free WordPress SEO audit tool that covers many of these points in under a minute.

Technical SEO (5–8 minutes)

1. Permalink structure

Where: Settings → Permalinks
What to look for:
If it’s set to “Plain” (?p=123), change it immediately to Post name (/%postname%/).
Plain permalinks are bad for users and for crawlers. Almost every site that isn’t a massive news portal with very specific URL requirements should use Post name.
After changing:
Check 3–5 older posts. If any 404, set up redirects (Redirection plugin or Rank Math / Yoast redirect features work fine). Most modern SEO plugins handle the bulk of this automatically.
Common mistake: Changing permalinks on a live site without checking redirects. Always test.

2. XML Sitemap

Check: yoursite.com/sitemap.xml or yoursite.com/sitemap_index.xml
Yoast, Rank Math, All in One SEO and most other plugins generate one automatically. If you get a 404, the sitemap is either not generated or blocked.

What to do:

Confirm the sitemap loads and contains your important pages
Submit it in Google Search Console and Bing Webmaster Tools
Watch the Coverage / Pages report for sudden drops in indexed URLs — this often points back to sitemap or robots problems

Pro tip: If you have a large site, check that the sitemap is split into multiple files and that pagination works. A single giant sitemap can cause issues.

3. robots.txt

Check: yoursite.com/robots.txt
Dangerous pattern I still see regularly:

User-agent: *
Disallow: /wp-admin/
Disallow: /wp-content/

Blocking /wp-content/ is almost never correct. CSS, JS, fonts and images live there. Search engines need to fetch them to understand how the page renders.
Safer minimal version:

User-agent: *
Disallow: /wp-admin/
Allow: /wp-admin/admin-ajax.php

Anything more aggressive (blocking specific plugins, query parameters, etc.) should be intentional and documented. When in doubt, be less restrictive.
Also check that important pages or directories are not accidentally blocked.

4. Broken links (internal first)

Broken internal links waste crawl budget and create dead ends for users. External 404s are less critical but still look unprofessional.
Quick approach:

Use a free crawler (Screaming Frog free version, Sitebulb trial, or online tools)
Or use the link checker in your SEO plugin / audit tool
Focus first on internal links from high-traffic pages and from the homepage / main menus Fix strategy:
Update or remove the link
Or set a 301 redirect if the target page moved For large sites, schedule a deeper crawl monthly. Don’t try to fix every external 404 on the first pass.

5. HTTPS and mixed content

The entire site should load over HTTPS. Mixed content (HTTP images, scripts or stylesheets on HTTPS pages) still triggers browser warnings and can affect trust signals.
How to check:

Chrome DevTools → Security tab
Or look in the Console for mixed-content warnings
PageSpeed Insights and most audit tools also flag this Fix: Update the source URLs to HTTPS or force HTTPS at the server / CDN / plugin level (Really Simple SSL, Cloudflare, or host-level settings). --- ## On-Page SEO (10–15 minutes)

6. Title tags

Every important page needs a unique title. Aim for under ~60 characters so it doesn’t get truncated in search results.
What to check on your top pages:

Is the title unique?
Does it contain the primary keyword near the beginning (when it still reads naturally)?
Is it written for humans or just stuffed with keywords? Generic titles like “Home”, “Services” or “Blog” waste valuable space. Tool tip: You can bulk-export titles with most SEO plugins or use a free browser extension / Screaming Frog.

7. Meta descriptions

Same rules as titles: unique, roughly under 155–160 characters, written for humans first.
Meta descriptions do not directly influence rankings, but they heavily influence click-through rate. A page that ranks well but has a weak or missing description is leaving clicks (and therefore rankings) on the table.
Write them like a short ad: clear benefit + keyword + reason to click.

8. H1 tags

One H1 per page. It should describe the main topic and preferably contain the primary keyword.
Multiple H1s still appear frequently with page builders (Elementor, Divi, Bricks, etc.) and poorly coded themes.
How to check: Inspect the page source or use the browser inspector. Search for <h1. If you see more than one, fix the template or the specific page.

9. Heading hierarchy

Correct order: H1 → H2 → H3 → H4.
Don’t skip levels just for visual design. Screen readers and search engines both prefer a logical outline.
Page builders make it very easy to create a visual hierarchy that doesn’t match the actual HTML heading tags. Always verify the real markup.

10. Image alt text + performance

Every meaningful image needs descriptive alt text.
IMG_20260725.jpg or empty alt attributes tell Google (and screen readers) nothing useful.
“WordPress SEO audit checklist screenshot” is useful.
Decorative images should have empty alt (alt="") so assistive technology skips them.
While you’re there:

Compress images
Serve modern formats (WebP / AVIF) where possible
Add proper width/height attributes to reduce CLS Performance and accessibility often improve together.

11. Internal links

Aim for 3–5 relevant contextual internal links on most content pages. Link to related posts, category hubs, pillar pages or key service pages.
This helps distribute authority and makes the site structure clearer to crawlers.
Avoid:

Footer or sidebar link spam
Linking to the same page over and over
Using exact-match anchor text on every link Contextual links inside the content work best.

12. Content length and quality

Thin pages (under ~300 words of real content) rarely rank for competitive terms. Pillar pages, money pages and important guides usually need 1,000+ words of genuinely useful material.
This does not mean padding. It means:

Answering the main query thoroughly
Covering related questions people also ask
Updating outdated sections
Removing fluff that adds no value Practical check: Look at your top landing pages by traffic. If organic traffic has slowly declined while the SERP became more competitive, content quality and freshness are often the first places to look. Also check for near-duplicate pages (especially category/tag pages and pagination) that may be competing with each other.

Schema, Social & Performance (5–10 minutes)

13. Structured data (Schema)

Run several key pages through Google’s Rich Results Test.

Look for valid JSON-LD. The most common high-value types on WordPress sites are:

Article / BlogPosting
FAQ
HowTo
Product
Organization
BreadcrumbList
WebSite (with sitelinks search box)

Most SEO plugins can output basic schema. Custom post types, complex templates or page-builder pages often need manual JSON-LD or a more flexible solution.
Invalid or missing schema means you are leaving rich results (and higher CTR) on the table.

14. Open Graph and Twitter Cards

Share 2–3 important pages on LinkedIn, Facebook or X and look at the preview.
Check:

Correct title
Correct description
Correct image (and that it looks good, not cropped or low-res) Missing or wrong OG tags produce ugly social shares and lower click-through from social traffic. Yoast and Rank Math handle the basics well. Double-check featured image dimensions if previews look bad.

15. Core Web Vitals

Test the homepage and 2–3 important templates (single post, archive, product page, etc.) in PageSpeed Insights.
Targets (mobile):

LCP < 2.5 s
CLS < 0.1
INP < 200 ms Most common WordPress culprits:
Heavy page builders
Unoptimized hero images
Render-blocking plugins and scripts
Too many marketing / tracking scripts
Lack of proper caching and CDN High-impact fixes:
Good caching plugin (or host-level caching)
CDN
Image optimization + modern formats
Delay or conditionally load non-critical JavaScript
Reduce the number of active plugins Deeper issues sometimes require changing the theme or how the page builder is used.

Priority order after the audit

Don’t try to fix everything at once. Suggested order:

Critical technical — Permalinks, robots.txt, HTTPS, major broken internal links, sitemap not working
High-visibility on-page — Titles and meta descriptions of top pages, missing H1s, obvious thin content on money pages
Performance — Core Web Vitals on homepage and key templates
Schema & social — Structured data on important pages, Open Graph
Ongoing content & internal linking — Systematic improvements over the following weeks Track the pages you changed. Give Google 2–4 weeks and then review rankings + organic traffic.

Useful free (or freemium) tools

Task	Tool	Notes
Crawl & broken links	Screaming Frog (free)	500 URLs limit
Core Web Vitals	PageSpeed Insights	Official
Rich results	Google Rich Results Test	Official
Search performance	Google Search Console	Essential
Bulk title/meta check	SEO plugin + export or SF	Rank Math / Yoast work well
robots.txt & sitemap	Browser + Search Console	Simple
Quick site audit	AuditMe	Free automated checks + WordPress-specific fixes

You can do a solid first-pass audit with almost no paid tools. For a faster overview of titles, meta tags and overall score, the free SEO analyzer is also handy.

Final notes

Most WordPress sites I look at have at least 4–7 clear, fixable issues sitting in the technical and on-page sections. The difference between “we should do an SEO audit someday” and actually finishing one is usually just having a concrete checklist and 40 focused minutes.
Do the technical part first. Then the top pages. Write everything down. Fix the high-impact items. Repeat in a few weeks or next month.
That’s it. Go run it on your site.
If you want, reply with the biggest issue you found — I’m curious what still surprises people in 2026.
You can also run a full automated check anytime at AuditMe.

Sources & further reading

This checklist is based on practical experience plus official documentation and established SEO references:

Official / primary sources

Google Search Central – Core Web Vitals
Google Rich Results Test
Google Search Console documentation
PageSpeed Insights Books
The Art of SEO (Eric Enge, Stephan Spencer, Jessie Stricchiola) — still one of the most solid foundational texts.
SEO for Growth by John Jantsch & Phil Singleton — practical and business-oriented.
The Beginner’s Guide to SEO (Moz) — free and regularly updated online version is excellent for fundamentals. Selected articles & guides
Search Engine Land – Core Web Vitals guides and updates
Semrush – On-page SEO checklist (regularly refreshed)
Ahrefs & Moz blog posts on technical SEO, internal linking and content audits

The core principles (crawlability, clear structure, useful content, good user experience metrics) have been stable for years. The tools and exact thresholds (especially Core Web Vitals and INP) continue to evolve, which is why re-checking every few months still makes sense.

Content Optimization for Search Engines: Beyond Keywords

Eduard — Sat, 01 Aug 2026 11:02:31 +0000

Content Optimization for Search Engines: Beyond Keywords

After auditing a SaaS blog last month I saw the same pattern I’ve been seeing for years: 200 well-written posts, almost none of them ranking. The writer came from journalism, so the prose was clean and readable. The problem was structural. Zero keyword targeting, no topical clusters, almost no internal linking. Pretty words with zero organic traffic.
This is the gap I keep running into. People either write for robots (keyword-stuffed nonsense nobody finishes) or they write purely for humans and act like search engines don’t exist. The real work sits in the middle — and it’s not as complicated as most SEO guides make it sound.

Keywords Aren’t Dead. They’re Just Different.
Where the Keywords Actually Belong
Topical Authority Is the Long Game That Still Works
E-E-A-T Isn’t a Checklist
Stop Writing Like a Textbook
AI Content Is the Elephant in the Room
Content Freshness: Update Only When It Matters
Final Thought

Keywords Aren’t Dead. They’re Just Different.

A few years ago you could force “best project management software” into a page eight times and rank. Those days are gone. Google understands context far better now. That doesn’t mean keywords stopped mattering. It means the way you use them changed.
When I start optimizing a piece I still do keyword research, but volume is only one signal. Intent is the bigger one. Someone searching “project management software” wants comparisons and pricing. Someone searching “how to manage a remote project team” wants a practical walkthrough. Same broad topic, completely different content.

I mostly use Ahrefs. SEMrush works fine too. The rule I learned the expensive way: match commercial-intent keywords to product pages and informational-intent keywords to the blog. Trying to rank a blog post for a high-intent transactional term is usually a multi-month waste of time.
Question-based keywords are still underrated. Featured snippets love clear, direct answers. I’ll take a question like “how many internal links should a page have,” answer it in the first two sentences of a section, then expand. That short direct answer often wins the snippet.

Where the Keywords Actually Belong

You don’t need to be surgical, but there is a practical hierarchy I follow:

Primary keyword near the front of the title tag, in the H1, and inside the first 100 words
Secondary keywords in H2s and H3s
Meta description should contain the primary keyword naturally — not forced, just present

Early in my career I cost a client three months of traction with a simple meta description mistake. We were targeting “enterprise SEO platform.” I wrote a clean, persuasive description that somehow never included the exact phrase. Google didn’t bold anything in the SERP. CTR sat at 1.2%. I added the keyword, kept the same position and the same content, and CTR moved to 3.8% in two weeks.

One thing I’ll push back on: obsessing over “LSI keywords.” Google does use related terms and entities, but most tools turn that idea into a checklist you sprinkle in. Don’t. Write thoroughly about the topic and the related concepts appear naturally. If you’re covering coffee makers you’ll mention grind size, water temperature, filter types and brew methods without forcing a list.

Topical Authority Is the Long Game That Still Works

Most people quit too early here. Topical authority is Google deciding you actually know a subject, not just ranking one lucky page. It takes consistent coverage of related subtopics over months.
I learned this with a project-management client. We had a strong pillar ranking around position 6 for “project management.” Traffic stalled. Looking at Asana and Monday.com showed the gap immediately — they had dozens of pages covering every angle: agile vs waterfall, remote team management, timeline estimation, tool comparisons. We were competing with one page against an entire ecosystem.

So we built a proper cluster: one 4,000-word pillar (“Complete Guide to Project Management”) plus four focused pieces on the subtopics. Descriptive anchor text both ways. Four months later the pillar moved from 6 to 2. The cluster pages together brought in roughly 22K monthly organic visits. Nothing revolutionary in any single post — just breadth and clear connections.

The practical version: pick your core topics, build 5–8 solid pieces around each one, and link them tightly. That’s still the most reliable way I’ve found to move the needle on competitive terms. For a deeper breakdown of this approach you can check the topical authority guide.

E-E-A-T Isn’t a Checklist

Google’s E-E-A-T framework (Experience, Expertise, Authoritativeness, Trustworthiness) gets treated like a box-ticking exercise: add an author bio, cite three sources, done. That misses the point.
I’ve audited plenty of sites with perfect author bios and “meet the experts” pages that still rank poorly. The content itself was shallow rehashes of whatever already sat on page one. E-E-A-T isn’t something you bolt on. It’s something the content demonstrates if it’s actually useful.
What moved the needle for me was adding first-hand experience: specific client numbers, what worked, what failed, the exact mistakes I made. Traffic improved — not because Google has a magic “experience detector,” but because those details make the piece more useful, and usefulness is what the ranking systems are getting better at measuring.
The Experience signal is still the most underused. If you’re reviewing a tool, show real screenshots of you using it. If you’re giving advice, say when it worked and when it didn’t. Generic advice doesn’t signal experience. Specific, slightly imperfect, real-world advice does.
For trustworthiness, cite sources. Not because Google necessarily gives a direct ranking boost (though it might), but because unsourced claims read like marketing copy. When I link to a study or reference concrete data, readers trust the piece more. Trust improves engagement metrics, and those still matter.

Stop Writing Like a Textbook

I used to write long dense paragraphs because I thought that felt “comprehensive.” It just made people leave. Time on page dropped, scroll depth was terrible, bounce rate sat around 78%.
Now I keep paragraphs short — usually two to four sentences. I drop a subheading every 200–300 words. I use bullets when a list is clearer than narrative. I deliberately vary sentence length so the rhythm doesn’t become hypnotic and boring.

I aim for roughly grade 8–10 readability. Not because Google cares about Flesch-Kincaid scores (it doesn’t), but because that range correlates with people actually finishing the article. If your content reads like a legal brief, most readers won’t get past the intro. For practical tips on writing that ranks without sounding robotic, see the SEO copywriting guide.

AI Content Is the Elephant in the Room

Almost every SEO is using AI to draft now. I use it too. Publishing raw AI output is still a bad idea.
Google’s helpful content systems specifically target low-effort mass-produced content. Even without that, generic AI writing underperforms. I tested it directly. I published an 800-word post that was pure AI draft — well structured, factually correct, zero edits. It landed at position 34 and stayed there. I rewrote the same topic with personal examples, specific numbers from my work, and actual opinions. Same structure, different soul. It moved to position 7 in about two months.
The workable approach is simple: let AI build the skeleton, then add the parts AI still can’t reliably produce — your experience, your specific data, your judgments, the stories that only come from doing the work. Verify every claim. Rewrite anything that sounds generic. Make sure at least one section could only have been written by someone who’s actually done this.

Content Freshness: Update Only When It Matters

Google cares about freshness for time-sensitive queries and mostly ignores it for evergreen ones. I still see people rewriting “What Is SEO?” every quarter when nothing substantial has changed. Don’t.
Update when the information is actually outdated, when you have meaningful new data, when competitors have clearly surpassed you, or when a real development lands in the topic. Changing the publish date after a meaningful update does help re-crawling. I had a post stuck at position 8 for six months. I added a solid new section with 2026 data, updated the date, and it moved to position 3 within a month. Freshness signals work — but only when the content itself is genuinely fresher.

Final Thought

Content optimization in 2026 is less about tricks and more about doing the unglamorous work consistently: matching intent, covering topics thoroughly, showing real experience, writing so people actually finish reading, and treating AI as a starting point rather than the finished product.

None of this is new. Most of it just requires patience and the willingness to go deeper than the average page ranking for the same terms. That still works.
If you want a quick second pair of eyes on a page you’re optimizing, drop the URL into the free SEO analyzer and look at the keyword placement, readability, and structure scores. The numbers won’t rank the page for you, but they usually show the gaps faster than staring at the draft yourself.

Image SEO: Complete Guide to Optimizing Images for Search

Eduard — Thu, 30 Jul 2026 07:37:16 +0000

A while back I audited an e-commerce site that looked solid on paper. Fast hosting, clean code, decent content. Mobile PageSpeed score: 34. I kept digging until I checked the page weight. Homepage was pulling 14MB of images on first paint. Fourteen megabytes. For a homepage.
Every product photo had been uploaded as a 3000px-wide PNG straight from the photographer’s camera. No compression, no resizing, no modern formats. Mobile users on 4G were downloading desktop-sized files. We converted everything to WebP, added proper responsive sizes, and got the total image payload down to about 800KB. Score jumped to 87. That single change — just the images — moved their Core Web Vitals from “poor” to “good” across the whole site.
That’s when it clicked for me. Image SEO isn’t some nice-to-have checklist item. On a lot of sites it’s the biggest performance bottleneck you’ll find.

Alt Text (and the mistakes I keep seeing)

Alt text does two jobs that people constantly mix up: it helps screen-reader users understand the image, and it gives search engines context so the image can show up in Google Images. Good alt text does both at once.
What I see in almost every audit:

“image of product”
or pure keyword stuffing: “buy blue widget online best price” Neither helps anyone. Something specific works better: “Woman hiking on mountain trail with red backpack at sunset” That’s useful for a screen reader and it tells Google exactly what it’s looking at. Keep it under roughly 125 characters. Screen readers often cut off after that, so longer text just gets ignored. Decorative images (background patterns, spacers, pure design elements) should get an empty alt: alt="". That way screen readers skip them instead of announcing “image”. Early on I made a classic mistake myself. I used the same alt text for every color variant of a product — “Blue running shoe” for the blue, red, and green versions. Google couldn’t tell them apart in image search. Each variant needs its own unique description. ## File names — the five-minute fix most people skip I still open sites and see IMG_4729.JPG and photo-1.png. File names are a ranking signal for images. Renaming them costs nothing and takes almost no time. What I do:
hyphens between words
include the main keyword
make it descriptive red-leather-wallet.jpg is already better than IMG_4729.JPG. seo-audit-checklist-2026.png tells Google (and future-you) exactly what the file is. ## Formats — my actual take, not the marketing version WebP is the right default for most photos. You usually get 25–35% smaller files than JPEG at similar quality, and support is over 96%. For product shots and complex images it’s the clear winner. But I don’t buy the “WebP for everything” advice. On screenshot-heavy tutorial pages I’ve seen WebP create ugly compression artifacts around sharp text edges. In those cases PNG looked better even though the file was larger. Sometimes the “best” format isn’t the best for your images. AVIF is technically stronger — up to 50% smaller than WebP — but support still sits around 80%. I use it as a progressive enhancement with a WebP fallback. Most people won’t notice, the ones on modern browsers get a faster load. SVG for logos and icons is non-negotiable. If your logo is still a PNG, fix it. Vectors scale cleanly and the files are tiny. Quick rule of thumb I use:
photos → WebP (or AVIF + WebP fallback)
screenshots / text-heavy images → PNG
logos & icons → SVG ## Responsive images — stop sending desktop files to phones This is the second biggest performance killer after raw file size. Without srcset, every mobile visitor downloads the full desktop image. Basic pattern:

<img
  src="image-800.jpg"
  srcset="image-400.jpg 400w,
          image-800.jpg 800w,
          image-1200.jpg 1200w"
  sizes="(max-width: 600px) 400px,
         (max-width: 1000px) 800px,
         1200px"
  alt="Descriptive alt text">

Phone gets the 400px version, tablet 800px, desktop 1200px. On that e-commerce site, just adding responsive images cut average image payload by about 60% for mobile users. That’s the difference between a 3-second load and a 1-second load on typical 4G.

Lazy loading — easy to get wrong

Native lazy loading has been around since 2020. Just add loading="lazy":

<img src="image.jpg" alt="Description" loading="lazy">

The mistake I still see constantly: people lazy-load the hero image. Above-the-fold content should load immediately. Lazy-loading the main visual tanks LCP because the browser waits to fetch the most important image on the page.
Also check your CDN or image optimization service. Some inject their own JavaScript lazy-loading that fights with the native attribute. Open Chrome DevTools and watch the network order — make sure the hero loads first and everything else waits.

Image sitemaps — Google can’t index what it never finds

Most images get discovered through the HTML. That fails for images loaded with JavaScript, CSS background images, or stuff buried in carousels and galleries.
Putting images in your XML sitemap gives Google a direct path:

<url>
  <loc>https://example.com/page</loc>
  <image:image>
    <image:loc>https://example.com/image.jpg</image:loc>
    <image:caption>Description of the image</image:caption>
  </image:image>
</url>

I’ve seen image search traffic double on sites after we added proper image entries to the sitemap. The images weren’t new — Google just couldn’t find them before.

Mistakes that show up in almost every audit

Oversized files — 3000px wide when the layout only needs 800px. Resize before you upload.
Wrong format — PNG product photos that should be WebP. The size difference hurts.
Missing or useless alt text — still the most common issue. In my last 20 audits, 14 had serious gaps.
Generic file names — banner-final-v3.jpg tells Google nothing.
No lazy loading (or lazy-loading everything, including the hero).
Leaving EXIF data — location and camera info. Some people keep it for context, I usually strip it on client sites for privacy. ## Tools I actually open
Squoosh — still my go-to for quick one-off compression. The quality slider is excellent.
TinyPNG — solid for batch PNG/WebP work.
Lighthouse (Chrome DevTools) — run it after every change so you can see the real impact.
Auditme — useful for spotting missing alt text, wrong formats, and images that lack responsive sizing across a whole site. ## Quick check If you want a fast look at your own images: Run a free image SEO analysis It flags alt text coverage, format issues, and whether lazy loading is set up correctly.

Eduard Tymchenko
Building tools that help people find and fix the SEO problems that actually move the needle.

I built a free SEO audit tool with 24+ features using Next.js 16, TypeScript, and AI — here's what I learned

Eduard — Wed, 29 Jul 2026 02:31:30 +0000

I spent 2 months building Auditme — a free SEO analyzer that checks 12 dimensions and generates AI recommendations. No signup, no paywall. Here's the technical breakdown.

What It Does

Paste any URL, get a full audit in 60 seconds. 12-dimension analysis:

Meta tags (title, description, OG tags, Twitter cards)
Heading structure (H1-H6 hierarchy)
Core Web Vitals (LCP, INP, CLS, FCP, TTFB)
Schema markup validation + suggestions
Content quality scoring
Internal & external link analysis
Image SEO (alt text, formats, lazy loading)
Redirect chain detection
Social media previews
E-E-A-T signals Plus 25 additional tools: schema validator, meta tag analyzer, keyword clusters, rank tracker, content editor, competitor diff, broken link checker, and more. ## The Stack | Layer | Tech | |-------|------| | Framework | Next.js 16 (App Router, Turbopack) | | Language | TypeScript strict | | Styling | Tailwind CSS v4 | | Database | Supabase | | AI | Gemini → Groq → Mistral (fallback chain) | | State | Zustand | | Components | shadcn/ui | | Deploy | Vercel | ## The Scan Pipeline Every URL goes through this flow:

URL Input → SSRF Check → Fetch HTML → Parse → Score 12 Dimensions → AI Insights → Response

The core scanner fetches raw HTML and extracts every SEO signal:

async scanURL(url: string): Promise<PageData> {
  const response = await fetch(url, {
    headers: { "User-Agent": "Mozilla/5.0 (compatible; AISEOCopilot/1.0)" },
    signal: AbortSignal.timeout(15000),
    redirect: "follow"
  });
  const html = await response.text();
  return {
    title: this.extractTitle(html),
    meta_description: this.extractMetaDescription(html),
    h1: this.extractH1(html),
    schema_markup: this.extractSchema(html),
    internal_links: this.countInternalLinks(html, url),
    external_links: this.countExternalLinks(html, url),
    images_without_alt: this.countImagesWithoutAlt(html),
    word_count: this.countWords(html),
    // ... 12 dimensions total
  };
}

Each dimension gets scored, then weighted into an overall score. Title, H1, meta description, and schema each carry more weight than, say, image count.

The Biggest Problems I Solved

1. SSRF Protection

The biggest security risk — users can scan ANY URL. Someone could scan http://169.254.169.254 (AWS metadata) and leak server keys.

function isSafeURL(urlString: string): { ok: boolean; error?: string } {
  const url = new URL(urlString);
  const hostname = url.hostname.toLowerCase();
  // Block private IPs, localhost, cloud metadata
  if (/^(10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.|127\.)/.test(hostname)) {
    return { ok: false, error: "Private IP blocked" };
  }
  if (["169.254.169.254", "metadata.google.internal"].includes(hostname)) {
    return { ok: false, error: "Cloud metadata blocked" };
  }
  return { ok: true };
}

Every API endpoint that accepts a URL now runs through this before fetching.

2. AI Provider Fallback Chain

If Gemini fails, try Groq. If Groq fails, try Mistral. If all fail, generate offline insights from the scan data itself.

async function aiGenerate(prompt: string) {
  const providers = [
    { name: "gemini", fn: callGemini },
    { name: "groq", fn: callGroq },
    { name: "mistral", fn: callMistral }
  ];
  for (const provider of providers) {
    try {
      const result = await provider.fn(prompt);
      if (result.text.length > 0) return result;
    } catch {
      continue;
    }
  }
  // All failed — offline analysis
  return { text: generateOfflineInsights(prompt) };
}

Users always get results, even when APIs are down.

3. AI Output Formatting

LLMs return markdown with **asterisks** everywhere. Users saw raw formatting in the UI.

function stripMarkdown(text: string): string {
  return text
    .replace(/\*\*([^*]+)\*\*/g, "$1")
    .replace(/\*([^*]+)\*/g, "$1")
    .replace(/^[-*]\s+/gm, "")
    .trim();
}

Simple fix, huge UX improvement.

4. Header Link Explosion

The scanner counts every <a href> in the DOM. My header had both desktop mega menu AND mobile menu always rendered — just CSS-hidden. Scanner saw 90 internal links and flagged it as "Internal Link Overload."

// Before: Always in DOM (90 links)
<div className={mobileMenuOpen ? "visible" : "hidden"}>
  {tools.map(tool => <Link href={tool.href}>...</Link>)}
</div>
// After: Only mounts when open (34 links)
{mobileMenuOpen && (
  <div>{tools.map(tool => <Link href={tool.href}>...</Link>)}</div>
)}

5. Rate Limiting in Serverless

Vercel serverless = each request is a new instance. In-memory rate limiting doesn't work across instances. Currently using in-memory solution. Planning Upstash Redis for distributed state.

Honest Results

28 days live. Google Search Console:

2 clicks, 2,330 impressions
Position 76.8 (page 8) The tool works well — tested against Ahrefs and Semrush, finds real issues. But without domain authority, Google doesn't care about features. Competing against DA 91 (Ahrefs) with DA ~5. ## What's Next
WordPress plugin for easier distribution
Redis for proper rate limiting
Custom domain ($12/year — budget is tight)
More blog content (15+ articles and growing)

🟢 Try It

www.auditme.dev — free, no signup, paste any URL.

Let's Build Together 🤝

I'm open to collaboration, strategic partnerships, or bringing in a co-owner/partner to scale this project, boost marketing, and take it to the next level.
Reach out to me on LinkedIn.

Built with Next.js 16, TypeScript, Supabase, and three AI providers. Open to feedback.

DEV Community: Eduard

How to Actually Raise Your Google PageSpeed Score in 2026

Table of Contents

What PageSpeed Insights Really Measures

Real Case Study: 42 → 91 in One Afternoon

The Five Things That Move the Needle Most

When the Score Lies

My Real Workflow (Not a Checklist)

The WebP (and AVIF) Trap + Code Example

Fonts That Don’t Block the Page

Why INP Matters More Than the Old FID

The Real 80/20

When to Stop

Quick Checks Before the Next Test

Related Guides

Sources & Further Reading

WordPress SEO Audit Checklist — 15 Things Worth Checking in 2026

Table of Contents

How to use this checklist

Technical SEO (5–8 minutes)

1. Permalink structure

2. XML Sitemap

3. robots.txt

4. Broken links (internal first)

5. HTTPS and mixed content

6. Title tags

7. Meta descriptions

8. H1 tags

9. Heading hierarchy

10. Image alt text + performance

11. Internal links

12. Content length and quality

Schema, Social & Performance (5–10 minutes)

13. Structured data (Schema)

14. Open Graph and Twitter Cards

15. Core Web Vitals

Priority order after the audit

Useful free (or freemium) tools

You can do a solid first-pass audit with almost no paid tools. For a faster overview of titles, meta tags and overall score, the free SEO analyzer is also handy.

Final notes

Similar useful articles

Sources & further reading

Content Optimization for Search Engines: Beyond Keywords

Content Optimization for Search Engines: Beyond Keywords

Table of Contents

Keywords Aren’t Dead. They’re Just Different.

Where the Keywords Actually Belong

Topical Authority Is the Long Game That Still Works

E-E-A-T Isn’t a Checklist

Stop Writing Like a Textbook

AI Content Is the Elephant in the Room

Content Freshness: Update Only When It Matters

Final Thought

Image SEO: Complete Guide to Optimizing Images for Search

Alt Text (and the mistakes I keep seeing)

Lazy loading — easy to get wrong

Image sitemaps — Google can’t index what it never finds

Mistakes that show up in almost every audit

I built a free SEO audit tool with 24+ features using Next.js 16, TypeScript, and AI — here's what I learned

What It Does

The Biggest Problems I Solved

1. SSRF Protection

2. AI Provider Fallback Chain

3. AI Output Formatting

4. Header Link Explosion

5. Rate Limiting in Serverless

Honest Results

🟢 Try It

Let's Build Together 🤝