Tutorial
What you will do in this afternoon, and what you need
This tutorial takes a slow WordPress site and walks you through a fixed order of work: measure, fix the biggest cause, measure again. You do not need to be a developer. You do need access to your WordPress admin, a way to restore the site if something breaks, and a few hours of uninterrupted time.
The reason for a fixed order is simple. Most speed advice is a long list of tweaks, and most of those tweaks change nothing you can see. A small number of changes do the heavy lifting. We group them into five, and we put them in the order that usually pays off first:
- Fix the server response. Hosting, PHP version and page caching decide how long the browser waits before it receives anything.
- Shrink and fix images. Images are usually the largest files on a page and very often the largest visible element.
- Remove weight from your theme and plugins. Every active plugin can add database queries, CSS, JavaScript or remote requests.
- Tame third-party scripts, fonts and render-blocking files. Analytics, chat widgets, embeds and web fonts are common causes of slow rendering and sluggish clicks.
- Add a CDN and clean the database. These help most once the first four are done.
Around those five changes, this guide covers how to measure properly, how to read what the tools tell you, and how to re-test so you know a change worked.
What you need before you start
- Administrator access to the WordPress dashboard.
- A recent backup you know how to restore. If you do not have a backup routine yet, read the backup routine every site owner needs first. It takes less time than the changes below, and it makes every step safer.
- A staging copy of the site if your host offers one. The staging site guide explains how to set one up.
- A web browser with developer tools. Chrome is used in this guide because Lighthouse is built into it, but Firefox and Edge have similar network panels.
- A text file or spreadsheet where you will record numbers before and after each change.
- Access to your hosting control panel, so you can check the PHP version and cache settings.
How the afternoon is structured
| Block | What you do | Result you record |
|---|---|---|
| 1 | Measure the current state with PageSpeed Insights, Lighthouse, WebPageTest and Query Monitor | A baseline table |
| 2 | Back up, then fix the server response: PHP version, page cache, hosting limits | New server response time |
| 3 | Fix images: sizes, formats, loading attributes | New largest element timing |
| 4 | Audit the theme and plugins, remove what you do not use | Fewer requests and queries |
| 5 | Fix fonts, CSS, JavaScript and third-party scripts | Better responsiveness and layout stability |
| 6 | CDN, database cleanup and a final re-test | Final table next to the baseline |
Do not skip block 1. If you start changing things without a baseline, you will not know which changes helped, and you may spend an hour on something that was never the problem.
What “slow” means: the numbers that matter
People say a site is slow when a page feels slow. Tools need something they can measure, so they break “slow” into specific metrics. You only need to understand a handful of them.
The three Core Web Vitals
Google and the web.dev project define three Core Web Vitals. Each one measures a different part of the experience, and each has a published threshold for “good”.
| Metric | What it measures | Good threshold (web.dev) |
|---|---|---|
| Largest Contentful Paint (LCP) | Loading: how long until the largest visible element on the page, often a hero image or a large heading, has rendered | 2.5 seconds or less |
| Interaction to Next Paint (INP) | Responsiveness: how quickly the page reacts visually after a click, tap or key press | 200 milliseconds or less |
| Cumulative Layout Shift (CLS) | Visual stability: how much content jumps around while the page loads | 0.1 or less |
web.dev measures these at the 75th percentile of page loads, split by mobile and desktop. A page passes only if all three meet the good threshold at that percentile. In plain terms: three out of four real visits should be at or better than the threshold. One fast visit on your office connection does not count.
For a deeper look at how these apply to WordPress themes and plugins, see the guide to Core Web Vitals on WordPress.
Time to First Byte (TTFB)
TTFB is the time from when the browser starts navigating to a page until the first byte of the response arrives. web.dev lists what contributes to it: redirects, service worker startup, DNS lookup, connection and TLS negotiation, and the time the server spends processing the request until it sends the first byte. web.dev gives a rough guide: 0.8 seconds or less is good, and more than 1.8 seconds is poor, with the range between needing improvement.
TTFB is not a Core Web Vital. It matters because it comes before everything else. A page cannot start to paint, and its largest element cannot render, until the HTML has begun to arrive. web.dev’s LCP guidance describes a well-optimized page as spending roughly 40 percent of its LCP time on TTFB, under 10 percent on resource load delay, roughly 40 percent on resource load duration, and under 10 percent on element render delay. These shares are guidelines, not fixed budgets. They are useful because they tell you where to look: if your TTFB is already most of your LCP, images and scripts are not your main problem.
Lab data and field data
The most common beginner confusion in speed testing is mixing up two kinds of data.
- Field data comes from real visitors. Google’s PageSpeed Insights reads it from the Chrome User Experience Report, which covers a trailing 28-day period. It reflects many devices and network conditions. If your page does not have enough visits, PageSpeed Insights may fall back to data for the whole site, or show nothing.
- Lab data comes from Lighthouse running a single simulated page load. Mobile tests emulate a mid-tier phone on a mobile network, and desktop tests emulate a desktop on a wired connection. Lab data is useful for debugging because it is repeatable and it comes with a detailed list of problems. But Google’s own documentation notes that it can miss real-world bottlenecks.
Field data tells you whether you have a problem. Lab data helps you find out why. Because field data is a 28-day rolling window, it will not move the day after you make a fix. Use lab data to check your work immediately, and field data to confirm over the following weeks.
The Lighthouse performance score
Lighthouse boils a page load into a score from 0 to 100. Google’s documentation groups it as 90 to 100 good, 50 to 89 needs improvement, and below 50 poor. It also warns that scores fluctuate between runs because of network conditions, hardware and resource contention. Treat the score as a rough indicator. A change from 62 to 68 on one run proves nothing. A change you can see in the timing of the largest element, repeated across several runs, does.
Do not chase a score of 100. A perfect score is not the goal and is not a requirement for a good visitor experience. The goal is that real visitors get fast pages. Stop when the Core Web Vitals are in the good range for your real traffic and the site feels quick.
Step 1: Measure before you change anything
This is the most important block of the afternoon. You will gather four kinds of evidence and put them in one table. Each tool answers a different question.
| Tool | Question it answers | Data type |
|---|---|---|
| PageSpeed Insights | How do real visitors experience this page, and what does Lighthouse flag? | Field and lab |
| Lighthouse in Chrome DevTools | What does a repeatable test on my own machine say, and what are the specific problems? | Lab |
| WebPageTest | What does the load look like step by step, from a chosen location and connection? | Lab |
| Query Monitor | Which database queries, hooks, scripts and remote requests happen inside WordPress, and which plugin causes them? | Server side |
Choose the pages to test
Do not test only the home page. Pick three to five pages that represent your site:
- The home page.
- A typical post or article page.
- Your most important landing page, such as a product, service or contact page.
- Any page that visitors complain about, or that has the most traffic in your analytics.
Write the exact URLs in your notes. You will re-test the same URLs later.
Run PageSpeed Insights
- Open the PageSpeed Insights website.
- Paste the full URL of your first page and run the analysis.
- Read the top section first. If there is a field data section titled with real-user experience, note the status of LCP, INP and CLS. If there is no field data, note that. It usually means the page does not have enough traffic.
- Switch between the mobile and desktop tabs. Note both. Mobile is usually the harder test.
- Scroll to the diagnostics and opportunities. Note the three items with the largest estimated savings, but treat the estimates as hints, not promises.
- Run the same URL two more times and note whether the numbers move. Variation between runs tells you how much noise to expect.
This PageSpeed Insights guide for WordPress goes through the report sections in more detail if you want to learn the layout.
Run Lighthouse in Chrome
Lighthouse is built into Chrome DevTools, so you can run it on pages that are behind a login or that PageSpeed Insights cannot reach.
- Open the page in a new Incognito window. This avoids extensions changing the result. Extensions are a common cause of misleading scores.
- Open Chrome DevTools and select the Lighthouse panel.
- Choose the Performance category, choose Mobile or Desktop, and start the analysis.
- When it finishes, note the score and the metrics shown, then open the list of opportunities and diagnostics.
The panel names and labels can change between Chrome versions. If you cannot find the Lighthouse panel, look for it in the menu of extra tools in DevTools.
Run WebPageTest
WebPageTest lets you pick a test location, browser and connection speed, and it records a waterfall chart of every request along with filmstrip views of what the page looked like over time. Use it for two things: checking the site from a location near your real visitors, and reading the waterfall.
- Open the WebPageTest website and enter your URL.
- Choose a test location close to the place most of your visitors live.
- Choose a mobile-like connection profile if most of your traffic is on phones.
- Run the test. Where the tool offers it, run multiple tests and use the median result.
- Open the waterfall and note the first request, which is your HTML document. If it takes long before the first byte arrives, you have a server response problem. If there are dozens of requests after it, you have a page weight or plugin problem.
The WebPageTest interface and the options available on free accounts have changed over time. If a setting here does not match what you see, follow the on-screen labels.
Install Query Monitor
Query Monitor is a free developer tools panel for WordPress, available from the WordPress plugin directory. Install and activate it like any other plugin: open the Plugins screen in the admin menu, add a new plugin, search for Query Monitor, install and activate.
Once active, it adds a menu to the admin toolbar that summarizes each page load. According to its plugin page it can show:
- Database queries, with slow, duplicate and erroneous queries flagged, and the ability to filter by the component responsible: a plugin, the theme, or WordPress core.
- PHP errors, deprecated function use and notices.
- Enqueued scripts and styles with their dependencies.
- HTTP API calls, meaning requests your site makes to other servers, with response codes, timing and the component responsible.
- Hooks, templates and blocks.
Output is limited to administrators by default. Browse your own site while logged in as an administrator, open the Query Monitor menu in the toolbar, and look at the overview, then the queries panel grouped by component. You are looking for a plugin that accounts for an unusually large share of queries or time, a remote request that takes a long time, and the same query repeated many times.
Remove Query Monitor when you are done. Its overhead is described as small, but it is a diagnostic tool and there is no reason to leave it active on a production site once you have your answers. Also be aware that memory use can be high on pages with hundreds of queries.
Record your baseline
Create a table like the one below in your notes and fill it in for each page. The numbers in this example are illustrative only. They are not from a real test and they are not typical results. Yours will be different.
| Page | Device | TTFB | LCP | INP | CLS | Lighthouse score |
|---|---|---|---|---|---|---|
| Home (example) | Mobile | 1.4 s | 4.1 s | 280 ms | 0.18 | 48 |
| Home (example) | Desktop | 1.1 s | 2.6 s | 150 ms | 0.05 | 71 |
| Article (example) | Mobile | 1.3 s | 3.7 s | 210 ms | 0.22 | 52 |
Add one column for notes: what the biggest flagged problem was. In the example above, you might note “hero image is the LCP element” or “first request takes most of the time”. That note is how you decide where to start.
Step 2: Read the results and find the real bottleneck
You now have numbers. The next job is to decide which of the five changes to make first. Do not work down the Lighthouse opportunities list in the order it appears. Use the symptom table below.
| What you see | Most likely cause | Go to |
|---|---|---|
| TTFB above about 0.8 s on uncached pages, or the waterfall shows a long wait on the first request | Slow hosting, old PHP, no page cache, heavy plugins running on every request | Server response and caching sections |
| LCP element is an image and its load time is long | Oversized images, wrong format, image loaded late or lazy-loaded | Images section |
| LCP element is a text block, and it appears late | Web fonts blocking text, render-blocking CSS | Fonts and CSS sections |
| INP above 200 ms | Heavy JavaScript, long tasks, third-party scripts | CSS and JavaScript and third-party sections |
| CLS above 0.1 | Images without dimensions, ads or embeds without reserved space, fonts swapping | Layout stability section |
| Query Monitor shows hundreds of queries or one plugin dominating | Plugin or theme doing too much work per request | Theme and plugin audit, database sections |
| Waterfall has many requests to other domains | Third-party scripts, fonts, embeds | Third-party scripts section |
| Fast on repeat tests but slow for visitors far away | Distance between server and visitors | CDN section |
How to read a waterfall in four steps
- Find the first row. It is your HTML document. Look at the part of the bar before the download begins. A long wait here is server time. If the first request is slow, nothing after it can be fast.
- Look at the order of the rows after it. CSS and JavaScript files requested in the document head are on the critical path. Look for long chains, where one file triggers another.
- Find the LCP element in the lab report and find its row in the waterfall. Note when it was requested and how long it took. If it starts late, the problem is discovery or priority. If it takes long to download, the problem is file size.
- Count requests and total transferred size. These are crude measures, but they help you notice the page that loads 90 requests from 30 domains.
If you are unsure which of two causes is the real one, do the cheaper fix first and re-test. That is the principle behind the whole afternoon: make one change, measure, keep or undo it.
Step 3: Back up and set up a safe way to test
Before you change anything, back up your site. Caching, image optimization and plugin changes can all break layouts, forms or checkout pages. A backup you have not tested is a hope, not a backup. The backup routine tutorial shows how to make one and how to test a restore.
Speed work is risky in a specific way: the breakage is often visual or intermittent. A cache that serves an old version of a page, a minification setting that breaks a menu on mobile, a lazy-load setting that leaves a gap. You may not notice these on your first look. So prepare:
- Use staging if you have it. Make changes on the copy, test them, and then repeat on live or push the changes across. See the staging site guide.
- Change one thing at a time. If you turn on five settings in a caching plugin and the checkout breaks, you will not know which one did it.
- Keep a change log. One line per change: what, where, time, result. It takes seconds and saves you when you need to undo something three weeks later.
- Test the pages that matter after each change. A menu, a contact form, a search, a login. If you run a shop, add a product to the cart and begin checkout.
- Know how to undo. For plugin settings, note the original value. For file changes, keep the original files.
A quick check after every change
- Open the home page and one article in a private window, as a logged-out visitor.
- Check the menu, the search box and any form on the page.
- Scroll the whole page and look for gaps, broken images and overlapping text.
- Repeat on a phone, or in the browser’s device emulation.
- Run the same test you ran for the baseline, and record the number.
Change 1: Fix the server response (hosting, PHP and TTFB)
The server response is first for a reason. Every other optimization happens after the HTML arrives. If the HTML takes too long, you cannot make up the time later. This section covers what you can check yourself, what to ask your host, and when the honest answer is to change plans or hosts.
What affects the server response
- Hardware and plan limits. The WordPress developer documentation notes that more CPU, more RAM and SSD or NVMe storage can make a large difference. On shared hosting, a plan with higher resource limits may help if you are hitting the limits of your current one.
- PHP version. The same documentation says newer PHP versions usually include better performance optimization, and that PHP accelerators such as OPcache can significantly improve PHP performance.
- Caching. A page served from a cache skips most of the work WordPress would otherwise do. More on this in the next section.
- Database speed. The database is queried on every uncached page. The WordPress documentation recommends using the InnoDB storage engine, and converting older MyISAM tables to it.
- Distance and DNS. The documentation recommends using an external DNS service, and notes that a CDN can reduce the impact of distance between your server and visitors.
- Redirects. web.dev lists redirects as a contributor to TTFB. A chain such as http to https to www to a trailing slash adds a round trip each time.
Check and update your PHP version
Your hosting control panel normally shows which PHP version your site uses and lets you change it. The WordPress admin may also show the PHP version on the Site Health screen under Tools. The exact location varies by host and by WordPress version, so follow the labels you see.
- Open Tools, then Site Health, then the Info tab, and open the Server section to see the PHP version. If you cannot find it, check your hosting control panel.
- Check the WordPress.org requirements page and your plugins’ and theme’s own documentation to see which PHP versions they support.
- Take a backup.
- In your hosting control panel, switch the site to a newer supported PHP version. If you have staging, do this on staging first.
- Browse the site, test forms and checkout, and check the PHP error log or Query Monitor for new errors and deprecation notices.
- If something breaks and a plugin is responsible, switch back to the previous version, then update or replace that plugin and try again.
The details, including how to pick a version, are in the guide to PHP versions and WordPress performance. This guide does not state which PHP version is best right now because supported versions change. Check the PHP project’s supported versions page and WordPress.org’s stated recommendations on the day you do this.
Questions to ask your host
If your TTFB is poor even on a cached page, the host is the likely cause. Instead of arguing about it, gather evidence and ask specific questions:
- Which PHP versions do you support, and is OPcache enabled?
- Is there a server-level page cache, and how do I control it? Is there an object cache I can enable?
- What are the CPU, memory and process limits on my plan, and does the dashboard show when I hit them?
- Which database server and storage engine do you use?
- Are there any resource limit warnings or throttling events on my account?
- Where is the server located, and can I choose a data center nearer my visitors?
When to change plans or host
You have probably outgrown your hosting if all of the following are true: the server response is slow on cached pages as well as uncached pages, your host shows or admits that you are at resource limits, and you have already removed obvious plugin overhead. The choice then depends on what you need. This hosting comparison by use case and the guide to managed hosting versus VPS cover the trade-offs. If you move, plan it properly with the migration guide, and keep your old host running until the new site is verified.
Do not buy new hosting as your first move. A slow server response can also come from a missing page cache or a plugin doing heavy work on every request. Rule those out first. Changing hosts is the most expensive fix and the one with the most risk.
Check that it worked
- Re-run WebPageTest or the browser’s network panel for the first request and note the wait before the first byte, as a logged-out visitor.
- Compare it with your baseline TTFB. Record the change.
- Run PageSpeed Insights again and check whether the server response time item has moved or disappeared.
Change 1, continued: Turn on the right caching layers
Caching means keeping a ready-made answer instead of building it again. WordPress builds each page by running PHP and querying the database. That is useful for dynamic sites, but most pages are the same for every visitor, so building them over and over is wasted work. There are several layers of caching, and they solve different problems. Beginners often install a plugin for one layer and assume the others are handled.
The layers, in plain words
| Layer | What it stores | Where it lives | What it speeds up |
|---|---|---|---|
| Page cache | The finished HTML of a page | On the server, as static files or in memory | TTFB for logged-out visitors |
| Object cache | Results of repeated database queries and computed data | A cache server such as Redis or Memcached, if your host provides one | Uncached pages, logged-in users, the admin, shops |
| Opcode cache (OPcache) | Compiled PHP code | The PHP engine on the server | Every PHP request |
| Browser cache | CSS, JavaScript, images and fonts | The visitor’s browser | Repeat visits and later pages in a session |
| CDN or edge cache | Files, and sometimes HTML, copied to servers near the visitor | A third-party network | Distance and load on your server |
The WordPress developer documentation describes the first four in its performance guidance. Caching plugins store posts and pages as static files, which reduces server processing, and the documentation says this can improve performance “several hundred times over for fairly static pages”. A persistent object cache reduces database trips, and requires a cache server from your hosting provider plus a compatible plugin. Browser caching uses HTTP headers such as Cache-Control with max-age, and Expires, plus entity tags, so browsers can reuse files that have not changed.
Step by step: page caching
First check what your host already does. Many hosts run a server-level page cache. If they do, adding a second page cache in a plugin can cause conflicts and double caching. Look in your hosting control panel for a cache setting, or ask support.
- Find out if there is already a cache. Open your page in a private window, open the browser’s network panel, select the document request, and look at the response headers. Many caches add a header showing a hit or miss, but the header name differs by host and plugin, so check your host’s documentation.
- If the host provides a cache, use it. Turn it on in the hosting panel, or through the host’s own plugin.
- If not, install one caching plugin. Only one. The caching plugin comparison lists the options, and the WP Rocket alternatives guide covers cheaper and free choices.
- Start with the page cache setting alone. Turn it on, leave other options at their defaults, and clear the cache.
- Test as a logged-out visitor. Browse the home page and an article in a private window. The first load after clearing may be slow because it builds the cache. Load it again.
- Test the pages that must not be cached. Cart, checkout, account and any page with personalized content. Check your caching plugin’s or host’s documentation to see whether it excludes these pages automatically, and confirm by testing a cart yourself.
Check that it worked
- Compare the TTFB of the first request in the waterfall, loading a page twice in a private window.
- If the second load is not clearly faster than before you enabled caching, something is stopping the cache from being used. Common causes: a cookie set on every page, query strings in the URL, or a logged-in session. Make sure you are testing logged out.
- Make a change to a post and confirm the visitor sees the update. If it does not, check the plugin’s setting for clearing the cache when content is updated.
Object caching
An object cache helps most on sites where pages cannot be fully cached: shops, membership sites, forums, and the WordPress admin itself. It needs a cache server, such as Redis, that your host provides, and a plugin or drop-in that connects WordPress to it. The Redis object cache guide explains setup. If your admin is slow even though the front end is fast, see the slow admin guide.
Do not install an object cache plugin unless your host confirms a cache server is available. Without one, the plugin will have nothing to connect to, and you will gain nothing.
Browser caching
Browser caching is usually handled by your host or caching plugin, which sets long cache lifetimes on static files. To check it, open the network panel, select a CSS, JavaScript or image file, and look at the response headers for Cache-Control. A static file with no caching header, or a very short lifetime, makes repeat visits slower than they need to be. Lighthouse also flags this in its diagnostics.
Caching and updates. After you change a theme file, stylesheet or plugin setting, you may need to clear the cache before you see the result. If a fix “does not work”, clear the page cache, and the CDN cache if you use one, before you conclude it failed.
Change 2: Fix images
Images are often the largest files on a page, and for many pages the LCP element is an image. An unoptimized hero image can account for most of the delay in a page. This is also the part of speed work with the most predictable payoff. The WordPress developer documentation advises removing unnecessary images, choosing the right format and compression level for each, considering WebP, and compressing media. The WebP and AVIF guide goes deeper on formats.
Find the images that matter
- In your Lighthouse or PageSpeed Insights report, find the LCP element. It tells you which image, if any, is the largest element.
- Open the network panel, filter to images, and sort by size. The largest files are your targets.
- Note the displayed size of each image on the page and the size of the file. A 4000 pixel wide photo displayed in a 800 pixel wide column is wasted bytes.
Choose a format
| Format | Good for | Notes |
|---|---|---|
| JPEG | Photographs | Widely supported. Quality setting trades file size for detail. |
| PNG | Screenshots, graphics with sharp edges, transparency | Often much larger than needed for photos. |
| WebP | Photos and graphics | The WordPress documentation notes WebP produces smaller files. Modern WordPress can upload and generate WebP images. |
| AVIF | Photos where you want the smallest files | Support depends on your WordPress version and server image library, so check before relying on it. |
| SVG | Logos and simple icons | Scales without quality loss. Only upload SVG files from sources you trust, because they can contain code. |
Step by step: resize and compress
- Know your content width. Find the widest an image is ever displayed on your site, in pixels. Many layouts never display an image wider than the content column, even on large screens, though full-width hero images are the exception.
- Resize before upload. Resize large originals to a sensible maximum width before uploading. WordPress creates several smaller copies of each upload, but the original large file is still stored and may still be used by some themes and blocks.
- Compress. Use an image optimization tool or plugin that compresses uploads. Choose lossy compression at a level where you cannot see a difference at normal viewing size.
- Convert to a modern format. Use a plugin or your host’s tooling to serve WebP, or upload WebP directly where your WordPress version supports it.
- Regenerate old images only where needed. A bulk re-optimization of your whole media library can take a long time and use a lot of resources. Start with the images on the pages you identified.
- Replace the images in the page. If you uploaded a new, smaller file, edit the page and swap it in, or let the plugin handle it.
Back up before bulk image changes. Bulk compression and conversion tools overwrite or replace files. Some can keep the originals, but do not assume. Check the setting and take a backup of the uploads folder.
Use the right size on the page
WordPress adds srcset and sizes attributes to images inserted through the editor, which lets the browser choose among several file sizes. This works only when the image is inserted from the media library with the generated sizes available. Images added by custom code, a page builder background setting, or an external URL may skip it. If your waterfall shows a huge file loaded on a phone, check how that image is inserted.
Loading attributes: lazy loading and priority
Two attributes matter, and they pull in opposite directions.
loading="lazy"tells the browser to delay an image until the visitor scrolls near it. It is good for images below the fold.fetchpriority="high"tells the browser to fetch an image early. It is good for the likely LCP image.
web.dev’s guidance on optimizing LCP says to make the LCP resource discoverable in the initial HTML, for example as an img element with a src or srcset in the markup, and to preload it if it is referenced only from CSS or JavaScript. It also says to use fetchpriority="high" on the likely LCP image, but only on one or two images, or the hint loses its value. And it says never to lazy-load the LCP image, since that adds delay.
WordPress handles part of this for you. The WordPress core team’s note on image performance in WordPress 6.3 says that WordPress now adds fetchpriority="high" to the image it judges most likely to be the LCP element, subject to a minimum size, and that it never returns both fetchpriority="high" and loading="lazy" for the same image. It also says the default threshold for skipping lazy loading on the first images was raised from 1 to 3. This means a current WordPress, with a standard theme, often gets the right result without your help. It can still go wrong when a theme or page builder outputs its own image markup, or when a plugin adds lazy loading to every image including the first.
- View the page source and find the LCP image’s
imgtag. Search the source for the file name. - If it has
loading="lazy", you have found a problem. Check your theme settings, your page builder’s image options, and any lazy loading or optimization plugin for a setting that excludes the first images or the featured image. - If the image is a CSS background rather than an
imgtag, the browser discovers it late. Consider switching to animgelement, or preloading it. - If the LCP image is not in the page source at all and appears only after JavaScript runs, a slider or script is delaying it. Replace the slider with a static image if you can.
Always set dimensions
Images need width and height attributes, or a CSS aspect-ratio, so the browser reserves space before the image loads. web.dev lists this as the first fix for layout shift. WordPress adds dimensions to images from the media library. Images in custom HTML blocks, custom code or some page builders may not have them.
Other image weight to remove
- Sliders and carousels. They load several large images, and often the script that runs them. A single static hero image is faster.
- Background videos. A looping video behind a heading can be much heavier than the rest of the page combined. If you need one, make sure it does not load on mobile and that a poster image is the LCP candidate.
- Embedded video players. An embedded player loads a lot of third-party code even if no one presses play. See the third-party section below.
- Unused images. Images in the library that no page uses cost storage and backup time, but not page load time. They are less urgent than images that are on pages.
Check that it worked
- Re-run Lighthouse and look at the LCP element. Check whether its timing improved and whether the opportunities for properly sizing images or next-gen formats have gone.
- Check the page visually on a phone and a desktop for blurry images. If you can see quality loss, raise the quality setting.
- In the network panel, confirm the file size of the LCP image has fallen and that its request starts early in the waterfall.
If your site is a shop with many product images, the WooCommerce speed checklist covers product gallery and archive page issues specifically. For image-related ranking factors beyond speed, see the image SEO guide.

Change 3: Audit your theme and plugins
A plugin or theme can slow a site in four ways: running slow code on each request, making many database queries, adding CSS and JavaScript to every page, and calling other servers. The WordPress documentation says to deactivate and delete unnecessary plugins, to disable plugins selectively to measure their effect, and notes that theme weight matters and that a lightweight theme performs better than a heavy one.
Make an inventory
- Open the Plugins screen and list every plugin, active and inactive.
- For each, write what it does in one line and who uses it. If you cannot say what a plugin does, that is a flag.
- Mark plugins that do the same job as another: two SEO plugins, two caching plugins, two security plugins, two form plugins.
- Mark plugins that only matter on one or two pages, such as a form or a map plugin, but load assets on every page.
- Mark plugins you could replace with a built-in WordPress feature. This guide to plugins you can delete lists common candidates.
Measure each plugin’s cost with Query Monitor
- Visit a page as an administrator with Query Monitor active.
- Open the Query Monitor menu in the admin toolbar and open the panel for database queries. Choose the grouping by component.
- Note which components run the most queries and the most time. Core is normally at the top. Look for any plugin that stands out.
- Open the panels for scripts and styles. Note which plugins add files to the page, and whether those files are needed on this page.
- Open the panel for HTTP API calls. Note any slow request to another server made during page generation, because it holds up your page until it returns.
- Repeat on two or three different page types.
Test by elimination, safely
Query Monitor shows you suspects. The only way to be sure is to turn a suspect off and measure. Do this on staging, or at a quiet time with a backup in place.
- Deactivate one suspect plugin. Do not delete it yet.
- Clear the cache.
- Re-run the test for the affected page and compare with the baseline.
- If the improvement is large, decide whether the plugin is worth its cost. Find a lighter alternative, or turn off its heaviest features, or limit where it loads.
- If the improvement is small, reactivate it and move on.
Deactivating plugins can break pages. A plugin that provides blocks, shortcodes or custom post types will leave gaps or raw shortcodes behind when deactivated. Check which pages use it first, and do not do this experiment on a busy live shop.
Decide: delete, replace, limit or keep
| Finding | Action |
|---|---|
| Inactive plugin | Delete it. Inactive plugins add no load, but they add update and security surface. |
| Two plugins with the same job | Keep one, migrate settings, delete the other |
| Plugin that loads assets on every page but is used on one | Check its settings for a way to load only where needed, or use a plugin or code to disable its assets elsewhere |
| Plugin with heavy queries or slow remote calls | Check settings, look for an update, ask the developer, or replace |
| Plugin you cannot identify | Find out who installed it and why, before removing |
| Plugin you need and that costs little | Keep it |
Before you add replacements, vet them. The guide to vetting a plugin before you install it lists what to check, and the plugin conflicts guide helps when removing or adding one causes a clash.
Your theme
A heavy theme loads large stylesheets and scripts, includes features you do not use, and may ship its own slider, icon library and animation library. To judge your theme:
- Switch to a default WordPress theme on staging and run the same test. If the numbers improve a lot, your theme is a large part of the problem.
- Look at your theme’s settings for options to turn off unused modules, icon fonts, animations and sliders.
- Check the page builder, if you use one, for settings that reduce output, such as loading only the CSS for elements used on the page.
- Consider a lighter theme if the theme is the bottleneck. A block theme can be lean, and the best block themes guide and the fastest WordPress themes guide list candidates. Treat any theme’s speed claims with caution and test it on your own content.
If you use a page builder, the builder’s own overhead is part of the picture. The page builders comparison and the Elementor alternatives guide discuss how builders differ. Switching builders or themes is a big job, so it is only worth doing when the test shows the theme or builder is the main cost.
Check that it worked
- Compare the number of requests and total transferred size before and after, in the network panel.
- Compare Query Monitor’s query count and total time on the same page.
- Run Lighthouse and see whether unused JavaScript and CSS diagnostics have shrunk.
- Test every feature that the removed plugin used to provide.
Change 4: Fonts
Web fonts affect speed in three ways: extra requests, render delay while text waits for the font, and layout shift when the fallback font is swapped for the web font. Fonts are a common reason an LCP element that is a heading arrives late.
What web.dev recommends
- Use
font-display. It controls how text is shown while a font loads. web.dev saysoptionalgives the best performance, since text is delayed by no more than 100 milliseconds and font-swap layout shifts are avoided, but the web font is skipped if it arrives late.swapshows text immediately with a possible shift when the font arrives. - Use WOFF2. It uses Brotli compression, which web.dev says is about 30 percent better than WOFF, and has the widest browser support.
- Use fewer fonts. System fonts need no download. Variable fonts can replace several files, though they are larger.
- Subset. Remove unused glyphs and use
unicode-rangeso only needed files download. Check the font license first. - Preload carefully. Preloading makes a font discoverable early, but it uses browser resources other files might need. Preload only the one or two fonts used above the fold.
- Self-hosting is not automatically faster. web.dev advises confirming you have a CDN and HTTP/2 first, and applying subsetting and WOFF2 yourself.
- Reduce shift with metrics. The
size-adjustdescriptor makes the fallback font closer in size to the web font.
Step by step
- List the fonts your pages load. In the network panel, filter by fonts. Note how many files and from which domains.
- Cut weights and styles you do not use. A site that loads regular, italic, bold, bold italic and three more weights often uses two of them.
- Check where fonts come from. If they come from a third-party font service, consider self-hosting them. The self-hosting fonts guide has the steps. Self-hosting removes a connection to another domain, and may also matter for privacy rules in some regions, but check the legal position for your situation instead of assuming.
- Set
font-display. In your theme settings, font plugin, or CSS. If the theme or the font tool offers a setting, use it before writing code. - Preload the main font only if the waterfall shows it starts late.
- Test text appearance. Load the page on a throttled connection and watch whether text is invisible for a while, or jumps.
A minimal example of a font declaration with a display strategy and WOFF2 file looks like this. The font name and path are placeholders. Replace them with your own.
@font-face {
font-family: "Example Sans";
src: url("/wp-content/uploads/fonts/example-sans.woff2") format("woff2");
font-weight: 400;
font-style: normal;
font-display: swap;
}
Check that it worked
- The number of font requests in the network panel has dropped.
- Lighthouse no longer flags text as hidden during font load, if it did before.
- CLS has not got worse.
Change 4, continued: CSS and JavaScript
CSS and JavaScript are the files that make a page look and behave the way it does. They also block rendering and occupy the browser’s main thread. Too much of either shows up as a slow LCP, a poor INP, or both. Most WordPress sites carry more of both than they need, because each plugin and the theme adds its own.
Understand the three problems
| Problem | What it means | Typical sign |
|---|---|---|
| Render-blocking resources | The browser must download and process some CSS or JavaScript before it can show anything | Blank screen at the start, high LCP, Lighthouse flags render-blocking resources |
| Unused code | Files loaded on the page that the page does not use | Lighthouse flags unused CSS or JavaScript |
| Long tasks on the main thread | Scripts that run for a long time and stop the page responding to clicks | High INP, page feels stuck after load |
web.dev’s guidance on INP explains why the third one matters. Every interaction has input delay, processing duration and presentation delay. Main-thread activity such as script parsing, compiling and execution during startup creates long tasks, and those delay the response to input. Splitting work into separate tasks keeps the main thread free sooner. Large DOMs also make rendering more expensive, which is another reason heavy page builders and huge pages hurt responsiveness.
Start with the simple options
- Remove what you do not use. The plugin audit above removes CSS and JavaScript at the source. This is always better than minifying or delaying it.
- Use the settings your tools already provide. Many caching and optimization plugins include options to minify, combine, defer or delay files. Many themes and builders also include options to load only the assets for elements on the page.
- Turn on one option at a time. Minification is usually safe. Combining files and delaying JavaScript are the options that most often break menus, sliders and forms.
- Test every time. After each option, test the menu, mobile menu, forms, search, any slider, and any popup, as a logged-out visitor on desktop and phone.
What defer and async do
web.dev explains the two attributes. async runs a script as soon as it downloads, so execution order is not guaranteed, and it can still block HTML parsing while it runs. defer runs scripts in document order after parsing finishes, without blocking the parser. WordPress supports adding these when a script is registered. If a plugin’s own script loading breaks when deferred, exclude that script in your optimization plugin’s settings instead of turning the feature off for everything.
Critical CSS and delayed loading
Some optimization plugins can generate critical CSS, the minimum styling needed to show the part of the page above the fold, and load the rest later. This can improve LCP but is also a common source of flicker and layout shift if it is generated incorrectly. If you try it, test on several page types and check for CLS afterwards. Some tools also delay JavaScript until the visitor first interacts with the page. This can help the first load but may make the first click feel slow, which is the thing INP measures. Always re-run your measurements after turning these on.
If something breaks after an optimization setting, do not guess. Turn off the last setting you changed. Your change log tells you which it was. Fix one script at a time by excluding it from the option, rather than abandoning the whole option.
Check that it worked
- Lighthouse reports fewer render-blocking resources, less unused JavaScript and less main-thread work.
- The network panel shows fewer and smaller CSS and JavaScript files.
- Interaction feels quicker. Click the menu and an accordion straight after the page loads and note any delay.
- No visual breakage on any template.
Change 4, continued: Third-party scripts and embeds
Third-party scripts are code loaded from other companies’ servers: analytics, advertising, chat widgets, social buttons, video embeds, maps, consent banners, heat maps, A/B testing tools. You do not control how fast they load, how big they are, or what they do once they run. They are one of the most common reasons a fast site still scores badly.
Inventory them
- Open the network panel and sort requests by domain, or open the WebPageTest results and look at the requests by domain breakdown.
- List every domain that is not yours. Group them: analytics, ads, chat, fonts, video, maps, social, other.
- For each, ask: does anyone use the data, the feature or the revenue it brings? If not, remove it.
- Check Query Monitor’s HTTP API panel for server-side calls that run during page generation.
Reduce their cost
web.dev’s guide to loading third-party JavaScript efficiently gives these options:
- Load asynchronously unless the script must run before the page renders.
- Use
deferfor less critical scripts, such as a video player below the fold. - Use
preconnectfor critical origins, so the connection is ready early. Limit it, because browsers close connections that go unused for about 10 seconds.dns-prefetchonly resolves the DNS and suits less important domains. - Lazy load non-critical or below-the-fold content, such as ads, until the main content loads or the visitor scrolls to it. For images and iframes the native
loadingattribute is an alternative to JavaScript. - Consider self-hosting a script. It reduces DNS lookups and round trips and gives you caching control, but you must update it manually. Do not self-host a script whose license, terms or privacy setup forbid it.
Common cases
| Source | Problem | What to try |
|---|---|---|
| Embedded video | The player loads a lot of code even if nobody plays it | Use a plugin or setting that shows a still image and loads the player only on click, or link to the video |
| Embedded map | Loads a full map script on page load | Load on click or scroll, or use a static image with a link |
| Chat widget | Loads at the start and adds main-thread work | Delay it until the visitor interacts, or load only on pages where it is useful |
| Analytics and tag managers | Several tags pile up over time | Audit tags, remove the dead ones, load the tag manager after the first paint if your setup allows |
| Social feeds and share buttons | Heavy scripts for little use | Replace with simple links |
| Ads | Late-loading content that shifts the layout | Reserve space for each slot |
| Consent banner | Can be the LCP element or cause layout shift | Check how the banner is inserted, and reserve its space or overlay it |
Do not remove consent or compliance tools to gain speed. If your site needs a consent banner for legal reasons, keep it and optimize how it loads instead.
Check that it worked
- The count of third-party domains has fallen.
- The waterfall no longer shows long chains of requests from other domains before the LCP element.
- INP has improved on pages where the removed script was running.
Fixing layout shift and slow interactions
Two of the three Core Web Vitals are about behavior after the first paint. Both are often neglected because they are less visible in a one-off test.
Layout shift (CLS)
web.dev lists the main causes of layout shift and the fixes:
| Cause | Fix |
|---|---|
| Images without dimensions | Set width and height, or CSS aspect-ratio |
| Ads, embeds and iframes | Reserve space with min-height or aspect-ratio, and keep the placeholder if nothing loads |
| Content injected dynamically | Reserve space in advance, or overlay the content so it does not push the page down |
| Web fonts swapping | Use font-display: optional, a closely matching fallback font, size-adjust and preload for critical fonts |
| Animations | Animate transform rather than top, left or box-shadow |
To find which element shifts, use the Lighthouse diagnostics section on layout shifts, which lists the elements that moved. Fix the worst one first and re-run. Banners, sticky headers that change height, cookie notices and announcement bars that appear after the page renders are frequent culprits.
Interaction delay (INP)
INP is harder to test in a lab, because it needs real interactions. Lighthouse does not report INP in the same way field data does, so use field data from PageSpeed Insights to see whether you have a problem, and use the browser’s performance panel to record clicking on a slow interaction and look for long tasks. The usual remedies are the ones in this guide: fewer scripts, delayed non-critical scripts, a smaller page, and fewer third-party tags. web.dev also notes that improving INP is iterative, because fixing one slow interaction often reveals others.
Change 5: Add a CDN
A content delivery network keeps copies of your files on servers in many places, and serves them from the one nearest to the visitor. The WordPress documentation notes that a CDN can reduce the impact of distance between your server and your visitors. It also takes load off your own server, because it answers requests for static files itself.
When a CDN helps and when it does not
| Situation | CDN value |
|---|---|
| Visitors spread across countries, server in one place | High |
| Many large static files: images, video, downloads | High |
| Traffic spikes that stress your server | High, if pages can be cached at the edge |
| All visitors near your server, small site | Low |
| Mostly logged-in or personalized pages | Lower, because those are hard to cache |
| Host already includes a CDN | Check before you add another |
Step by step
- Check whether your host already provides a CDN or edge caching. If it does, enable it and skip adding another.
- If you add one, pick a service and read its WordPress documentation. The Cloudflare setup guide covers one common option.
- Follow the provider’s instructions for DNS or plugin setup. Changing DNS records can take your site offline if done wrong, so note the current records first.
- Start with the default settings. Aggressive caching rules, minification and script rewriting at the edge are another source of breakage.
- Check that HTTPS works and that no mixed content warnings appear.
- Make sure the cart, checkout, login and admin pages are not cached at the edge.
- Test from a location far from your server, using WebPageTest.
Check that it worked
- Response headers for static files show that they are served by the CDN. Header names depend on the provider, so check its documentation.
- WebPageTest from a distant location shows a lower time to first byte for static files and, if edge page caching is on, for HTML.
- You can still log in, and updates to a post show up for visitors after you clear the cache.
Change 5, continued: Clean the database
Every uncached page asks the database questions. A database full of old revisions, expired transients, spam comments and leftover plugin data does not necessarily make a page slow, but it can make queries slower and backups larger. The WordPress documentation suggests limiting the number of revisions stored, using InnoDB, and keeping autoloaded options under roughly 800 KB. Autoloaded options are loaded on every request, so a large amount of autoloaded data slows every page.
Back up the database before you clean it. Database cleanup deletes data, and some of it cannot be recovered without a backup. Never run a cleanup tool on a live site without a backup that you know can be restored.
What is safe and what is risky
| Item | Risk | Notes |
|---|---|---|
| Spam and trashed comments | Low | Empty them regularly |
| Trashed posts and drafts you no longer need | Low | Check before you delete |
| Expired transients | Low | WordPress normally removes them, but cleanup tools can clear leftovers |
| Old post revisions | Medium | You lose the ability to roll back to them. Keep recent ones. |
| Orphaned data from deleted plugins | Medium to high | Only remove data you can identify as belonging to a plugin you have removed for good |
| Table optimization | Low to medium | Can lock tables on a large database. Run during quiet hours. |
| Changing autoload on options | High | Only for options you understand. Wrong changes can break plugins. |
Step by step
- Take a database backup and confirm the file exists and is not empty.
- Look at what is large. A database tool or plugin can show table sizes. Typical large tables are the posts table (because of revisions), the post meta table, the options table and the comments table.
- Delete spam and trashed comments from the Comments screen.
- Limit future revisions. You can set a limit in
wp-config.phpwith the documented constant shown below. This affects only future revisions. - If you want to remove old revisions, use a reputable cleanup plugin or your host’s tool, and keep a number of recent ones.
- Check the autoloaded options total. If it is above the roughly 800 KB level the WordPress documentation mentions, find which options are largest, and which plugin they belong to. If the plugin is gone, the data can probably go. If it is active, ask the plugin’s support.
- Re-run Query Monitor on a few pages and compare the query time with your baseline.
define( 'WP_POST_REVISIONS', 5 );
Add that line to wp-config.php above the comment that says to stop editing. Edit this file carefully, because a typing error can take the site down. Keep a copy of the original. The database cleanup guide goes through the details and the safer tools.
Check that it worked
- The database size has fallen, or the autoloaded total has.
- Pages and the admin still work, and forms, comments and logins are fine.
- Query Monitor shows no new errors.
If your site is a shop
Online shops are harder to speed up, because cart, checkout and account pages cannot be cached the same way and every page may need live stock and price data. The five changes still apply, with these differences: a persistent object cache matters much more, cache exclusions for cart and checkout need to be right, and product images and gallery scripts are a large share of page weight. The WooCommerce speed checklist and the checkout optimization guide cover shop-specific details. Test a complete purchase after each change, using a test payment mode where your payment gateway supports one.
The re-test routine
Speed work is not a one-off. Sites get slower as plugins, images and scripts accumulate. A short routine keeps the gains.
Right after each change
- Clear every cache: the plugin cache, server cache and CDN cache.
- Run Lighthouse in a private window, on the same pages, mobile first.
- Run it three times and use the median, because single runs vary.
- Record the numbers next to the baseline.
- Test the page visually and test the features.
- If the change made nothing better, undo it, unless it is a good practice you want to keep.
At the end of the afternoon
- Repeat the whole baseline: PageSpeed Insights, Lighthouse, WebPageTest, Query Monitor.
- Make a before and after table. Below is an illustrative layout. These numbers are examples only, not results from any real site.
| Metric (example) | Before | After | Change made |
|---|---|---|---|
| TTFB, mobile | 1.4 s | 0.5 s | Page cache on, PHP updated |
| LCP, mobile | 4.1 s | 2.3 s | Hero image resized, not lazy-loaded |
| INP | 280 ms | 170 ms | Removed chat widget and one plugin |
| CLS | 0.18 | 0.04 | Image dimensions, reserved banner space |
Over the following weeks
- Check the field data in PageSpeed Insights after about four weeks, because it is a 28-day rolling window.
- Check Google Search Console’s Core Web Vitals report if you have it set up. The Search Console guide explains how.
- Re-test after every major change: a new plugin, a theme update, a redesign, a new tracking script.
- Add speed checks to your regular maintenance. The maintenance checklist shows where they fit.
A rule for new additions
Before you add a plugin, script or font, ask what it costs. Test the page before and after. If a new item adds a visible cost, decide whether its benefit justifies it. This habit prevents most future slowdowns.
Troubleshooting: symptom, cause, fix
| Symptom | Likely cause | Fix |
|---|---|---|
| Scores did not change after enabling caching | You tested while logged in, or the page is excluded, or a second cache is conflicting | Test logged out in a private window, check exclusions, make sure only one page cache is active |
| Site shows old content after an edit | Cache not cleared on update | Clear the cache, and check the plugin’s rules for purging on update |
| Menu or slider stopped working | Script deferral, delay or combination broke a dependency | Turn off the last option or exclude the script |
| Images look blurry | Compression too aggressive, or the image is scaled up | Raise quality, or upload a larger source |
| LCP got worse after enabling lazy loading | The LCP image is lazy-loaded | Exclude the first images or featured image from lazy loading |
| Layout jumps after the page loads | Missing dimensions, injected banners or ads, font swap | Reserve space and set dimensions, see layout shift section |
| Lighthouse score changes every run | Normal variance | Run three times and use the median |
| Field data in PageSpeed Insights has not improved | It is a 28-day window | Wait, and rely on lab data meanwhile |
| Site broke after changing PHP version | A plugin or theme is not compatible | Switch back, update or replace the plugin, try again |
| Admin is slow but front end is fast | Plugin load in the admin, no object cache, heavy dashboard widgets | See the slow admin guide, enable object cache if available |
| Fast in one country, slow in another | Distance from the server | CDN, or host closer to visitors |
| Checkout or cart behaves oddly | Cached page that should not be, or script delay | Exclude those pages from caching and from script delay |
If a fix leaves the site broken and you cannot find the cause quickly, restore your backup and apply changes one at a time. If you suspect the site has been hacked rather than just slowed down, for example if there are strange redirects or new admin users, stop and read the hacked site recovery guide. For broader coverage of performance topics, read the full WordPress speed optimization guide.
Common mistakes to avoid
- Installing several optimization plugins. They overlap, conflict, and make problems hard to trace. Use one tool per job.
- Chasing the score instead of the visitor. A score is a proxy. Check the real field data and test on a real phone.
- Testing only the home page. Other templates have different problems.
- Testing while logged in. You will see an uncached, admin-bar-loaded version of the page that visitors never get.
- Changing many settings at once. You will not know which one helped or broke something.
- Optimizing images but not setting dimensions. You fix size and keep the shift.
- Lazy-loading everything. It delays the one image the visitor most needs.
- Ignoring the server. No front-end tweak fixes a slow response.
- Believing an estimate. The savings Lighthouse lists are estimates, so confirm with a real before and after test.
- Skipping the backup. The one time it matters is the time you did not make one.
Recap checklist
- I recorded a baseline for three to five pages, on mobile and desktop, in field and lab data.
- I have a tested backup and a way to undo changes.
- My PHP version is current and supported by my plugins and theme.
- One page cache is on, and cart, checkout and account pages are excluded.
- I know whether my host offers an object cache, and I use it if it does.
- The LCP image is sized, compressed, not lazy-loaded and discoverable in the HTML.
- All images have dimensions.
- I deleted unused plugins and compared the cost of the heavy ones.
- I trimmed fonts to what I use, and set a display strategy.
- I tested minification, deferral and delay one setting at a time.
- I removed or delayed third-party scripts that did not earn their cost.
- A CDN is in place, if my visitors are far from my server.
- I cleaned the database safely after a backup.
- I re-tested, filled in the before and after table, and set a date to check field data.
What to do next
Once the site is fast, protect it. Set up a backup routine so that a mistake or an attack does not undo your work. Make sure each page also does its job in search by writing good titles, as covered in the title tags tutorial, and keep an eye on the wider SEO picture. If you build pages with the block editor, the block editor basics tutorial shows how to keep layouts light. If your host is the limit, return to the hosting comparison.
FAQ
How long should this take?
For a small site, an afternoon is realistic for measurement, the server and caching steps, images and a plugin audit. Fonts, scripts and the database can take longer on larger sites. We have not timed any of these steps on real sites, so treat the title as a target, not a promise.
What is a good Lighthouse score?
Google’s documentation groups 90 to 100 as good, 50 to 89 as needs improvement and below 50 as poor. Scores vary between runs. Real-user Core Web Vitals matter more than a single score.
What are the Core Web Vitals thresholds?
web.dev lists good as an LCP of 2.5 seconds or less, an INP of 200 milliseconds or less and a CLS of 0.1 or less, measured at the 75th percentile of page loads.
Why is my PageSpeed Insights score different from Lighthouse in Chrome?
They run on different hardware, networks and conditions. Lighthouse in PageSpeed Insights runs on Google’s servers with an emulated device, and your local run uses your machine and connection. Extensions can also change local results.
Why does PageSpeed Insights show no field data?
Field data comes from the Chrome User Experience Report. If a page does not have enough visits, PageSpeed Insights may fall back to data for the whole site, or show none. In that case rely on lab data.
Do I need a caching plugin?
Only if your host does not already provide page caching. Check your hosting panel first. Running two page caches can cause problems.
Will a CDN fix a slow site?
Not by itself. A CDN helps with distance and static file delivery, but it will not fix a slow server response on uncached pages, heavy plugins or giant images.
Should I lazy-load every image?
No. web.dev says never to lazy-load the LCP image. Lazy load images that are below the fold.
How many plugins is too many?
There is no safe number. A site with ten well-built plugins can be faster than one with three heavy ones. Judge by measured cost, using Query Monitor and before and after tests.
Is it safe to delete post revisions?
It is safe in the sense that WordPress keeps working, but you lose the ability to restore those versions. Take a backup, keep recent revisions, and set a limit going forward.
Does my host matter more than my plugins?
It can. If the server response is slow even for cached pages, no front-end change can fix it. Measure TTFB first to find out.
My field data is poor but my lab scores are good. Why?
Real visitors use slower devices and networks than the lab simulation, and they interact with the page, which lab tests mostly do not. Look at INP and at the experience on real mobile devices.
How often should I re-test?
After every significant change, and as part of your regular maintenance. Check field data monthly if you have enough traffic for it to be available.
Let your AI assistant do this for you
Open the ready prompt with step‑by‑step instructions for running it through NibWP.