How to Speed Up a WordPress Site: A Practical Checklist

Illustration of a speedometer with a high needle in front of a browser window, with a small lightning bolt

A WordPress site usually does not get slow all at once. It gets slow by accumulation: a hero image straight from a phone camera, a plugin installed for one feature you used twice, a theme that loads three font families, a host whose server is an ocean away from your readers. Nothing in that list feels like a decision, which is why the slowdown surprises people. Speed is one lever among several in our web hosting and website series.

The fix is rarely one thing either. It is a short sequence of unglamorous checks, done in the right order. This checklist walks that sequence: measure first so you know what “slow” means for your site, then work through the causes from the largest and cheapest wins to the structural ones. The thresholds and tool references below come from Google’s web.dev documentation and the official WordPress Performance Team, linked in Sources.

Key takeaways

  • Measure before you change anything. Google defines “good” page experience with three Core Web Vitals: LCP at or under 2.5 seconds, INP at or under 200 milliseconds, and CLS at or under 0.1, measured at the 75th percentile of real page loads.
  • Images are the most common large win. WordPress 6.5 added native AVIF support, and AVIF files can be up to 50% smaller than JPEG at equivalent quality, per the WordPress core team’s release notes.
  • Page caching is the second big win and often one setting, either at your host or via a caching plugin.
  • The official Performance Lab plugin from the WordPress Performance Team bundles upcoming core performance features, including modern image formats and speculative loading, for free.
  • A perfect 100 score in PageSpeed Insights is not the goal. Passing the Core Web Vitals thresholds with real user data is.

Step 0: Measure, so “slow” has a meaning

“The site feels slow” is not actionable. A number is. Google’s answer to “which number” is the Core Web Vitals, three metrics that cover the three ways a page can annoy someone:

  • Largest Contentful Paint (LCP) measures loading: how long until the main content appears. Good means 2.5 seconds or less from when the page starts loading.
  • Interaction to Next Paint (INP) measures responsiveness: how fast the page reacts when someone taps or clicks. Good means 200 milliseconds or less. INP became a stable Core Web Vital in March 2024, replacing First Input Delay, per the web.dev announcement.
  • Cumulative Layout Shift (CLS) measures visual stability: whether things jump around while loading. Good means a score of 0.1 or less.

Lab data versus field data

Two details from Google’s documentation matter more than the thresholds themselves. First, the targets apply at the 75th percentile of page loads, split by mobile and desktop: you are not chasing your own best-case visit on fast wifi, but what most of your visitors actually experience. Second, there is a difference between lab data (a simulated test) and field data (measurements from real visitors, collected via the Chrome User Experience Report). Field data is the verdict; lab data is the debugging tool.

Run your homepage and one typical article through PageSpeed Insights. It shows both kinds of data when enough real-user measurements exist. Write down your three numbers. Every step after this one exists to move a specific number, and re-running the same test is how you know a change worked instead of hoping it did.

0. Measure: PageSpeed Insights LCP 2.5s – INP 200ms – CLS 0.1, at the 75th percentile 1. Images AVIF or WebP, right-sized; top image loads eagerly 2. Page caching Serve saved HTML instead of rebuilding each visit 3. Plugin audit Deactivate, re-measure, remove what costs speed 4. Hosting Server location and plan set your speed floor 5. Third-party scripts Fonts, embeds, trackers: each one has a cost 6. CDN Serve files from a location near each reader 0. Measure: PageSpeed Insights LCP 2.5s – INP 200ms – CLS 0.1 (75th pct) 1. Images AVIF or WebP, right-sized; top image eager 2. Page caching Serve saved HTML, not fresh rebuilds 3. Plugin audit Deactivate, re-measure, remove 4. Hosting Server location and plan set your floor 5. Third-party scripts Fonts, embeds, trackers each cost time 6. CDN Files served near each reader
The order matters: measure first, then fix in rough order of typical impact. Steps 1-3 are usually settings and deletions; steps 4-6 are structural.

Step 1: Fix images first

On a typical blog page, images are the heaviest assets by a wide margin, and the main content image is very often the LCP element itself. That makes images the fix with the biggest payoff for most sites.

Use a modern format. Since WordPress 6.5, you can upload AVIF images just like JPEG or PNG, as long as your hosting environment supports the format. Per the WordPress core team, AVIF files can be up to 50% smaller than JPEGs at the same visual quality. If AVIF is not available in your setup, WebP is the fallback and is also far smaller than an equivalent JPEG. The official Performance Lab plugin includes a Modern Image Formats feature that can generate modern formats for you.

Upload the size you actually display. A 4000-pixel photo from a phone, shown in a 760-pixel content column, forces every visitor to download several times the pixels they can see. Resize before uploading, and let WordPress’s built-in responsive images serve the right variant per screen.

Let lazy loading do its job. WordPress lazy-loads images by default, so below-the-fold images do not block the first view. The important corollary: do not lazy-load your main top-of-page image. That one should load immediately, because delaying it directly hurts LCP.

Step 2: Turn on page caching

By default, WordPress rebuilds every page on every visit: PHP runs, the database is queried, the HTML is assembled, and only then does the visitor see anything. Page caching saves the finished HTML and serves that copy to the next visitor, skipping the rebuild entirely. For a content site where most visitors read the same articles, this is often the single largest server-side win, and it is frequently one toggle.

Check in this order: your host first, a plugin second. Many managed and shared WordPress hosts run server-level caching and ask you not to stack a caching plugin on top. If your host offers it, enable it and test. If not, a well-maintained caching plugin from the official WordPress.org directory does the same job. After enabling, re-run PageSpeed Insights and watch what happens to the initial server response time (TTFB) reported in the diagnostics.

Step 3: Audit your plugins

Every active plugin can add PHP work on the server, CSS and JavaScript on every page, and database queries you never asked for. The cost is not the number of plugins but what each one loads, and one heavy plugin can cost more than ten light ones.

The audit is boring and effective. Open your plugin list and ask of each one: what breaks if this is gone? For anything you do not actively use, deactivate it, re-run your speed test, and look for movement in LCP and INP. Plugins that inject sliders, popups, page builders, or social feeds on every page are the usual suspects. If a plugin provides one small feature you use on one page, look for a lighter alternative or accept the cost knowingly. The WordPress Performance Team’s Performance Lab plugin is worth installing deliberately: it is the official collection of performance features being prepared for WordPress core, including Modern Image Formats, Image Prioritizer, Embed Optimizer, and Speculative Loading.

Step 4: Look at your hosting honestly

Caching and images can only take you so far, because your host sets the floor: the time it takes the server to answer at all, and how far the data physically travels to each reader. If your initial server response time stays high after caching is on, the bottleneck is the hosting itself.

Two levers exist before you change anything drastic. Server location: pick a region close to most of your readers, because distance is latency. And plan type: an overloaded entry-level shared plan has a lower ceiling than a well-resourced one. If you are weighing that trade-off, our comparison of shared, VPS, and managed WordPress hosting breaks down what actually changes between them. Move only after the cheaper steps are done, though: migrating hosts to fix an image problem is an expensive way to avoid resizing a photo.

Step 5: Trim third-party scripts and fonts

Third-party code is rented functionality, and the rent is paid in load time. Web fonts, analytics tags, chat widgets, embedded videos, social buttons, ad scripts: each one adds connections, downloads, and main-thread work, and each one can hurt INP by keeping the browser busy when a visitor tries to interact.

The discipline is the same as with plugins: for each script, name what it earns. Keep what pays for itself, remove what was installed once and forgotten. For what remains, reduce the cost: limit font families and weights, prefer system fonts where the design allows, and make sure embeds do not load until they are needed. The Performance Lab plugin’s Embed Optimizer exists for exactly this job, lazy-loading embeds such as videos so they do not slow the initial page.

Step 6: Add a CDN when your audience is spread out

A content delivery network keeps copies of your static files (images, CSS, JavaScript) on servers around the world and serves each visitor from a nearby location. If your server is in the US and a reader is in Australia, a CDN can remove hundreds of milliseconds of pure travel time from every asset, without changing your site at all.

Many hosts bundle a CDN or offer one as an add-on, and standalone free tiers exist. This step is listed last deliberately: a CDN makes a well-built site fast everywhere, but it does not fix a site that is slow at the source. Do steps 1 to 3 first, then let the CDN multiply the result.

The checklist, summarized

Step What to check Tool or method What “done” looks like
0. Measure LCP, INP, CLS with real-user data PageSpeed Insights LCP at or under 2.5s, INP at or under 200ms, CLS at or under 0.1 at the 75th percentile
1. Images Format, dimensions, lazy loading AVIF or WebP; resize before upload; Performance Lab Modern Image Formats Main image is not multi-megabyte; top image loads eagerly, the rest lazy
2. Caching Page cache active Host setting, or a caching plugin if the host does not provide one Server response time (TTFB) drops in re-test
3. Plugins What each plugin loads and earns Deactivate suspects one by one and re-measure No plugin active without a current job
4. Hosting Server location, plan ceiling TTFB after caching; host plan details Server answers quickly after steps 1-3
5. Scripts and fonts Every third-party tag justified PageSpeed Insights diagnostics; Performance Lab Embed Optimizer Fewer third-party requests; INP improves
6. CDN Static files served near readers Host add-on or standalone CDN Assets load from nearby locations worldwide

What not to obsess over

A perfect 100 score. The PageSpeed score is a lab approximation, not the goal. Google’s documentation defines success as passing the Core Web Vitals thresholds with real user data at the 75th percentile. A site at 82 that visitors experience as fast beats a site at 99 that stripped out things readers wanted.

Stacking optimization plugins. Two plugins trying to minify, defer, and cache the same resources can conflict and make things worse, or break pages outright. One caching layer, one image-format solution, one place where each job is done.

Rebuilding everything at once. Change one step, re-measure, keep what worked. If you change five things and the site gets faster, fine; if it gets slower or breaks, you will have no idea which change did it. The checklist is a loop, not a leap.

Chasing milliseconds nobody feels. Shaving 40 milliseconds off an already-passing page is a hobby, not an improvement. Spend that effort on the next article, or on a proper pre-launch review like our website launch checklist.

WordPress speed: quick answers

Do I need a caching plugin if my host already caches?

Usually no, and stacking both can cause conflicts or stale pages. Check your host’s documentation or dashboard first; many WordPress hosts run server-level caching and explicitly ask you not to add another caching layer.

Will more plugins automatically slow my site?

Not automatically. What matters is what each plugin loads: one plugin that injects scripts and database queries on every page can cost more than a dozen that do one quiet job. Judge by measurement, not by count.

Is a 100 PageSpeed score worth chasing?

No. Per Google’s documentation, the meaningful bar is the Core Web Vitals thresholds measured on real visits. The lab score is a debugging aid, and squeezing out the last points often means removing features your readers actually use.

How often should I re-check speed?

After any change that touches the front end: a new plugin, a theme update, a new embed or script, a redesign. The test takes a minute; discovering a regression from your analytics months later does not.

Sources

  • web.dev, “Web Vitals” – the Core Web Vitals definitions and thresholds (LCP 2.5s, INP 200ms, CLS 0.1) and the 75th-percentile, mobile-and-desktop measurement guidance: https://web.dev/articles/vitals
  • web.dev, “Interaction to Next Paint is officially a Core Web Vital” – INP becoming a stable Core Web Vital in March 2024, replacing First Input Delay: https://web.dev/blog/inp-cwv-launch
  • WordPress.org plugin directory, “Performance Lab” – the WordPress Performance Team’s official plugin and its feature list, including Modern Image Formats, Image Prioritizer, Embed Optimizer, and Speculative Loading: https://wordpress.org/plugins/performance-lab/
  • WordPress Core, “WordPress 6.5 adds AVIF support” – native AVIF uploads from WordPress 6.5, up to 50% smaller than JPEG at equivalent quality, hosting support required, and WordPress’s default responsive images, fetch priority, and lazy loading: https://make.wordpress.org/core/2024/02/23/wordpress-6-5-adds-avif-support/
  • PageSpeed Insights – Google’s tool for lab and field (Chrome User Experience Report) performance data: https://pagespeed.web.dev/

Similar Posts