Technical Basics for Blogs: Speed, Mobile and Sitemaps
Understand the three Core Web Vitals, weigh photos and pages against a budget, read field data with a 75th percentile and know what a blogger can fix without being an engineer.
In this lesson you will
- Name the three Core Web Vitals and their targets
- Weigh a page against a budget
- Read field data with a percentile
- List the fixes a blogger can make
About 25 minutes
Priya’s post is slow
Priya opens her seed-starting post on her phone while standing at the plot, where the signal is weak. The page crawls, and a message from a reader says the same thing. Advanced bloggers care about the technical side because slow pages lose readers before they read a word. You do not need to be an engineer for this. You need to know which few things matter, how to measure them and what to ask your host and your theme to do.
Three measures of a good page
Google describes page experience with three Core Web Vitals, and web.dev publishes the targets. Largest Contentful Paint (LCP) is how long the biggest thing on the screen, usually a photo or a heading, takes to appear. Interaction to Next Paint (INP) is how quickly the page responds when someone taps or clicks. Cumulative Layout Shift (CLS) is how much the page jumps around while loading, such as a button that moves just as you tap it.
- LCP: good at 2.5 seconds or less, poor above 4 seconds.
- INP: good at 200 milliseconds or less, poor above 500.
- CLS: good at 0.1 or less, poor above 0.25.
A page counts as good on a measure when at least three quarters of real visits reach the good level, which is called the 75th percentile. That choice stops a few very slow visits from ruling the verdict. Google also says plainly that page experience is one signal among many and a small one. Fast pages are worth having mainly because readers prefer them. Targets can change, so check web.dev for the current ones.
Photos are usually the heaviest part
Most of a blog post’s weight is its pictures. The program below makes a made-up noisy photo, saves it at full size and at web size, and compares the cost of a page. It also compresses a page of text with gzip, which most hosts do automatically, and checks the totals against a budget of 500 KB. That budget is my own rule of thumb for a small blog, not an official number.
import gzip, math, os
import numpy as np
from PIL import Image
# A MADE-UP photo (synthetic noise picture) saved at two sizes
rng = np.random.RandomState(5)
base = np.tile(np.linspace(0, 255, 1600), (900, 1))
pix = np.clip(base + rng.randint(-25, 26, (900, 1600)), 0, 255).astype("uint8")
photo = Image.fromarray(np.stack([pix, pix[::-1], pix[:, ::-1]], axis=2))
photo.save("big.jpg", quality=92)
photo.resize((800, 450)).save("web.jpg", quality=80)
big, web = os.path.getsize("big.jpg") // 1024, os.path.getsize("web.jpg") // 1024
print("big photo:", big, "KB")
print("web photo:", web, "KB")
page = "<p>Seeds on a windowsill, one pot at a time.</p>\n" * 300
packed = len(gzip.compress(page.encode())) // 1024 + 1
budget = 500
for label, size in (("big", big), ("web", web)):
total = packed + 3 * size
print(f"page with 3 {label} photos: {total} KB", "ok" if total <= budget else "over budget")
# MADE-UP field timings from 20 page views
lcp = [1.8, 2.1, 1.6, 3.9, 2.4, 1.9, 2.2, 5.1, 2.0, 2.6, 1.7, 2.3, 2.8, 1.9, 2.1, 4.4, 2.0, 2.7, 1.8, 2.2]
inp = [90, 120, 80, 310, 150, 110, 95, 520, 100, 140, 85, 130, 160, 105, 99, 260, 120, 115, 90, 125]
cls = [0.02, 0.05, 0.01, 0.30, 0.04, 0.03, 0.02, 0.12, 0.05, 0.06, 0.02, 0.04, 0.07, 0.03, 0.05, 0.09, 0.02, 0.06, 0.03, 0.04]
def p75(values):
s = sorted(values)
return s[math.ceil(0.75 * len(s)) - 1]
def verdict(value, good, poor):
return "good" if value <= good else ("poor" if value > poor else "needs work")
for name, data, good, poor in (("LCP s", lcp, 2.5, 4.0), ("INP ms", inp, 200, 500), ("CLS", cls, 0.1, 0.25)):
v = p75(data)
print(f"{name} at 75th: {v} {verdict(v, good, poor)}")
print("slowest LCP view:", max(lcp), "s")
big photo: 652 KB
web photo: 40 KB
page with 3 big photos: 1957 KB over budget
page with 3 web photos: 121 KB ok
LCP s at 75th: 2.6 needs work
INP ms at 75th: 140 good
CLS at 75th: 0.06 good
slowest LCP view: 5.1 s
The full-size photo weighs 652 KB and the web-sized one 40 KB, from the same picture. A post with three full-size photos comes to 1957 KB and is over budget, while three web-sized photos give 121 KB, which is fine. The text, once compressed, is almost free. The lesson is not to avoid photos. It is to resize them to the width they will really be shown at, and to save them at a sensible quality, as lesson 7 explained. A real camera photo will give different sizes, so run this on your own images.
Reading the field data
The second half of the program takes twenty made-up page views and works out the 75th percentile for each measure. LCP comes to 2.6 seconds, which is rated ‘needs work’, because it sits just above the 2.5 second line. INP is 140 milliseconds and CLS is 0.06, and both are good. The slowest single view took 5.1 seconds, yet it did not decide the verdict, which is the whole point of using a percentile. Real tools such as the Core Web Vitals report in Search Console use real visitors, called field data, over a recent period. Tools that test one page on your own machine give lab data. Lab data is handy for fixing problems, and field data is the truth about readers.
What a blogger can do
- Resize photos before uploading, and use modern image formats if your tools support them.
- Load fewer plugins and a lighter theme. Each one adds code to every page.
- Turn on caching, which stores ready-made pages, using your host or a plugin.
- Give images and adverts a fixed space so the page does not jump while loading.
- Ask your host what they offer: compression, caching and a recent version of the language your site runs on.
Mobile and sitemaps
Most readers arrive on phones, so test every new layout on a small screen first. A sitemap is a file listing the pages you want found. Most blogging systems and SEO plugins create one for you, and you can tell Google about it in Search Console. It helps, but it does not make a page rank. A page also needs links pointing to it, as lesson 11 showed.
Chasing a perfect score in a testing tool while ignoring what readers see. Fix the biggest problem first, usually photos, then measure again. A page that is good enough for readers is good enough.
The photos and timings here are made up, and real results depend on your host, theme, plugins and readers. Targets and tools change, so check web.dev and Search Console for the current ones. Hosting plans and prices change too, so none are quoted.
Practice for this lesson
Check what you learned
Five quick questions. Pick an answer and you will see straight away whether it is right and why.
Which Core Web Vital measures how fast the biggest item appears?
- Interaction to Next Paint
- Largest Contentful Paint
- Cumulative Layout Shift
- Page rank
LCP times the largest visible item.
Why does a 75th percentile make sense for the verdict?
- It ignores readers
- It is the average
- It only counts desktops
- A few very slow visits cannot decide it
The percentile is less swayed by outliers.
What usually makes a blog post heavy?
- Its photos
- Its headings
- Its links
- Its title
Images are normally the biggest share of page weight.
What is field data?
- A test on your own computer only
- Made-up numbers
- Measurements from real visitors
- A sitemap
Field data is what real readers experienced.
What does a sitemap do?
- Guarantees a ranking
- Speeds up photos
- Blocks bots
- Lists pages you want found
It helps discovery but does not make a page rank.
Summary
- LCP, INP and CLS describe loading, responsiveness and stability.
- Photos are usually the heaviest part, so resize them.
- A 75th percentile of real visits gives the verdict.
- Speed is a small signal but readers prefer fast pages.
Questions
Do I need to hit every target to rank?
No. Google says page experience is one small signal among many. Aim for pages that feel fast to readers and fix the biggest problems first.
Which tool should I use?
Search Console shows field data for sites with enough visitors. Page testing tools give lab data for fixing. Use both, and check their current names and pages.
Will a faster host fix everything?
Not always. Photos, plugins and the theme often matter more. Ask your host about compression and caching, and measure before and after.
