Recommended Free Tools
Check a WordPress site in layers rather than trusting one speed score. Start in Tools > Site Health for WordPress, PHP, plugin, theme, server and database warnings. Then test representative public URLs with Google PageSpeed Insights and WebPageTest. Read Largest Contentful Paint (LCP), Cumulative Layout Shift (CLS), Interaction to Next Paint (INP), First Contentful Paint (FCP) and Time to First Byte (TTFB) together. Classify the delay as front-end, server-side or third-party, change one variable, and repeat the tests under the same conditions.
Antihost offers managed WordPress hosting with free migration, one-click staging and a 14-day free trial.
This method tells you both what visitors experience and what is causing it. A low score alone does not identify the right fix, and one test run is not reliable enough for a performance decision.
As an Amazon Associate I earn from qualifying purchases.
What a WordPress performance check should answer
“Fast” is not one measurement. A useful check answers several different questions:
- Can WordPress generate the page quickly, or is the server slow before the browser receives anything?
- Does the browser display the main content promptly?
- Do images, fonts, scripts or advertising move content while the page loads?
- Does the page respond quickly when a visitor clicks, types or opens a menu?
- Are plugins, themes, database work or external services adding avoidable work?
- Is the result a repeatable problem or a one-off caused by network or machine load?
Use WordPress’s own diagnostics for configuration clues, public testing services for visitor-facing behavior, and profiling tools when you need to locate a specific query, hook or server operation. Each layer measures a different part of the delivery chain.
#1 Best Overall
Prepare a repeatable test before changing anything
Write down the exact final URL, test date, device mode, browser, connection profile and test location for every run. Keep those choices unchanged while evaluating one change. Redirects, logged-in sessions, cookie banners and personalized content can otherwise make two apparently identical tests measure different pages.
Choose pages that represent your site
Test the homepage and the important templates visitors actually use. A practical set usually includes a published post, a landing page, a category or archive page and, when applicable, a product or checkout page. This is a testing recommendation, not a mandatory WordPress list; the purpose is to expose template-specific problems that a homepage test can miss.
Free tools Windows power users keep installed
One-click scans. No signup required.
- Use a fully public URL for visitor tests unless you are deliberately investigating an authenticated experience.
- Record the final URL after redirects, including the protocol and trailing slash behavior.
- Choose a representative page with typical images, embeds, forms and navigation rather than an unusually empty page.
- Keep the same page content, active plugins, theme and WordPress version while comparing runs.
Separate a baseline from an experiment
Run a baseline before installing a plugin, changing a cache setting or editing code. Save the result pages or export their details. After the change, repeat the same URLs and conditions. If several settings change at once, you will not know which one helped or introduced a regression.
Start with WordPress Site Health
Site Health is the first native check because it can reveal an operational problem before you spend time tuning browser assets.
- Sign in to the WordPress administrator.
- Open Tools > Site Health.
- Review the Status tab from top to bottom.
- Open Info and inspect the environment details relevant to the issue.
- Export the information if a host or developer needs the same configuration record.
Read the Status tab by severity
The Status tab groups findings into critical issues, recommended improvements and passed tests. Treat a critical item as a stability or availability problem first. Recommended items may not explain every slow page, but they identify conditions worth correcting before you draw conclusions from a benchmark.
Rank #2
Site Health can flag outdated PHP, failed updates, loopback failures, blocked HTTP requests and related conditions that affect how WordPress runs. A loopback failure, for example, can interfere with scheduled or internal requests even when a public page appears to load. Resolve the underlying condition or document why it is intentionally present before optimizing cosmetic details.
Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problemsUse the Info tab to document the environment
The Info tab exposes WordPress, themes, plugins, media, server, database, constants and filesystem details. Note the PHP version, active theme, active plugins, memory-related constants, database information and server software. These details help explain why two sites with similar page designs can have very different response times. Host-controlled settings may require the provider’s assistance; do not assume an administrator-level WordPress change can alter them.
Measure public pages with PageSpeed Insights
Google PageSpeed Insights combines two kinds of evidence: controlled laboratory analysis and Chrome User Experience Report (CrUX) field data for eligible pages. It offers separate mobile and desktop views and produces improvement suggestions.
- Open PageSpeed Insights and enter one of the exact public URLs from your test list.
- Run the mobile view and record the displayed metrics and opportunities.
- Run the desktop view separately; do not treat it as a substitute for mobile.
- Read the lab section to reproduce a problem under controlled conditions.
- Read the CrUX field section as evidence of how real visitors experienced the page when enough eligible data exists.
- Record the URL, date, device view and notable recommendations before making a change.
Lab and field results answer different questions. A lab run is useful for isolating a render-blocking script or oversized image because the setup is controlled. Field data reflects a distribution of real devices, networks and visits, so it can reveal an issue that your own test machine does not reproduce. A page may have a reasonable lab result but poor field experience, or the reverse.
Rank #3
- Used Book in Good Condition
Do not turn the score into a diagnosis
PageSpeed’s score summarizes several signals; it does not tell you whether the server, a theme, a plugin or an external widget is responsible. Open the detailed opportunities and diagnostics, then connect each suggestion to the affected asset or request. If the same recommendation appears across several representative templates, it is more likely to be a shared theme, plugin or hosting concern than a single-page content anomaly.
Use WebPageTest to see the loading sequence
WebPageTest is useful when you need more control and a visual explanation of what happens during a load. You can select locations, browsers and connection speeds, then inspect a waterfall and detailed optimization information.
- Enter the final public URL.
- Choose a location close to your important audience, and keep it fixed for comparisons.
- Select the browser and connection speed that represent the scenario you want to investigate.
- Run multiple views if you need to distinguish a first view from a repeat view, but record which one you used.
- Open the waterfall to see connection setup, server response, blocking resources and late-loading assets.
- Review image analysis, optimization opportunities and the environmental impact report for additional clues.
The waterfall helps separate phases that a single score blends together. A long wait before the first response points toward connection or server timing. A quick response followed by a long chain of blocked scripts points toward browser work. A late, large image or font request can explain a delayed main visual even when the server responded promptly.
Understand the metrics that matter
| Metric | What it measures | How to use it in diagnosis |
|---|---|---|
| Largest Contentful Paint (LCP) | When the largest visible element becomes available. | Inspect the main image, heading or content block and the resources delaying it. |
| Cumulative Layout Shift (CLS) | How much visible page content moves unexpectedly while loading. | Look for images or ads without reserved space, late fonts, injected banners and expanding components. |
| Interaction to Next Paint (INP) | How promptly the page responds after a visitor interacts. | Find long JavaScript tasks, event handlers or third-party scripts that block the main thread. |
| First Contentful Paint (FCP) | When the first piece of content appears. | Use it with LCP to distinguish an initially blank page from a page whose main content arrives late. |
| Time to First Byte (TTFB) | The time until the first byte arrives from the server. | Investigate hosting, network infrastructure, PHP execution, database work and caching when it is disproportionately long. |
These metrics describe different stages. FCP and LCP concern rendering, CLS concerns visual stability, INP concerns interaction, and TTFB concerns the start of the response. Improving one does not guarantee that the others improve.
Classify the bottleneck before choosing a fix
Front-end bottlenecks
Large or inefficiently delivered images, web fonts, carousels, popups, bloated themes and plugin assets increase browser work or transfer time. Use the waterfall and PageSpeed diagnostics to identify the exact file or script. An image-heavy post may need content-level optimization even when the theme is sound; a site-wide script appearing on every template suggests a shared component.
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Server and WordPress bottlenecks
Hosting capacity, network infrastructure, server hardware, PHP configuration, database operations and cache behavior influence TTFB. If the first byte is delayed before significant browser work begins, inspect Site Health’s server details and ask the host for logs or configuration information. A slow query or expensive hook can affect every request generated by a template.
Third-party bottlenecks
Analytics, advertising, social widgets, video embeds, chat tools and externally hosted fonts can add DNS lookups, connections, JavaScript execution or layout changes. Compare the page with the service disabled only in a controlled staging or test scenario, and make sure the comparison still represents the experience you intend to publish. A third-party request may be outside WordPress’s control, but its cost is still part of the visitor’s performance.
Profile deeper when page tests are not enough
A page score shows the symptom; profiling can identify the operation. WordPress Core Performance guidance lists several options for deeper investigation:
- Query Monitor: inspect database queries, hooks, HTTP requests and related WordPress execution details.
- XHProf: profile PHP execution when you need function-level information about server-side work.
- Server-Timing: expose backend timing data so browser tools can show where server processing is spent.
- Web Vitals: collect the loading and interaction signals that matter to the visitor experience.
- Field data: observe production behavior rather than relying only on a controlled test machine.
Use profiling on a staging copy where possible, especially when enabling diagnostics adds overhead or exposes sensitive information. Match a slow public URL to its template, then narrow the investigation to the queries, hooks, HTTP calls or PHP functions used by that template.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Repeat tests correctly
Performance varies between requests. WordPress Core Performance documentation notes that even the same URL tested twice can produce slightly different results. A single run can be distorted by network congestion, a busy test server, CPU load on your computer or a cache state that differs from the previous run.
- Keep the WordPress version, database, content, theme and active plugins unchanged while establishing a baseline.
- Use the same URL, device mode, browser, location and connection profile.
- Run several requests rather than selecting the best or worst result from one attempt.
- Record the spread of results and look for a consistent pattern.
- Change one variable, then repeat the same sequence.
- Keep the change only if the relevant metric or loading phase improves without creating a new problem elsewhere.
For example, if you change image delivery, do not simultaneously switch themes and enable a new cache layer. If the result improves, the isolated change gives you a defensible explanation; if it worsens, rollback is straightforward.
Turn findings into an action plan
When TTFB is the main delay
- Confirm the server and PHP details in Site Health.
- Check whether page caching is active and correctly serving the tested URL.
- Ask the host to investigate server load, PHP workers, database latency and network behavior when the delay persists.
- Use Query Monitor or server-side profiling to find expensive queries or hooks.
When LCP or FCP is delayed after a quick response
- Identify the element that becomes the first or largest visible content.
- Inspect its image, font, stylesheet and script dependencies in the waterfall.
- Reduce unnecessary blocking work and ensure critical resources are delivered early.
- Check whether a carousel, popup or consent layer is covering or replacing the intended main content.
When CLS is high
- Reserve dimensions for images, video, advertisements and embeds.
- Look for late-injected banners, cookie notices and expanding navigation.
- Check font loading behavior for swaps that visibly move text.
- Repeat the test with a clean cache to distinguish a first-load layout change from a repeat-view issue.
When INP is poor
- Use the browser performance details to find long main-thread tasks.
- Audit event handlers attached by themes and plugins.
- Test third-party scripts separately because their execution can block interactions even when they are not hosted on your server.
- Remove or defer nonessential work only after confirming that the affected feature remains usable.
Build a practical comparison of checking methods
| Method | Data type | Control | Diagnostic depth | Access needed |
|---|---|---|---|---|
| WordPress Site Health | Configuration and operational checks | WordPress environment | Finds updates, PHP, plugin, theme, server, database and filesystem clues | Administrator access |
| PageSpeed Insights | Lab results plus CrUX field data | Mobile or desktop test scenarios; field data reflects real visitors | Metrics and improvement diagnostics | Public URL |
| WebPageTest | Controlled synthetic page loads | Selectable location, browser and connection speed | Waterfall, asset analysis, optimization details and environmental report | Public URL |
| Query Monitor or XHProf | WordPress and PHP execution details | Specific request or staging environment | Queries, hooks and function-level server profiling | WordPress or server access, depending on tool |
| Server-Timing and field data | Backend timing and production behavior | Real deployment conditions | Correlates server work with visitor-facing metrics | Implementation and monitoring access |
Common mistakes that produce misleading results
- Testing only the homepage: archive, post, product and checkout templates can load different assets and queries.
- Mixing mobile and desktop runs: the device and network assumptions are different, so the numbers are not a before-and-after pair.
- Comparing different URLs: redirects, query strings and trailing slashes can change caching and page content.
- Relying on one lab run: transient network and machine load can dominate a single result.
- Confusing field and lab data: CrUX describes eligible real visits, while lab data describes a controlled test scenario.
- Changing several things at once: you lose the ability to attribute the result and to roll back safely.
- Optimizing a score instead of a problem: a higher score is not useful if the checkout interaction, main content or accessibility worsens.
- Ignoring host responsibility: WordPress settings cannot correct every server, PHP or database limitation.
A repeatable WordPress performance checklist
- Open Tools > Site Health and resolve or document critical findings.
- Export or record the Info tab’s WordPress, PHP, plugin, theme, server and database details.
- Select the homepage and representative content templates.
- Record each final URL and the test location, device, browser and connection.
- Run PageSpeed Insights for mobile and desktop, keeping lab and CrUX observations separate.
- Run WebPageTest when you need a waterfall or a controlled location, browser or connection.
- Review LCP, CLS, INP, FCP and TTFB as separate signals.
- Classify the likely cause as front-end, server-side or third-party.
- Profile queries, hooks or PHP functions when page-level evidence is insufficient.
- Change one variable, rerun several requests and compare the same scenarios.
- Check other representative templates before deploying a site-wide change.
- Keep a dated record so later regressions can be compared with the same baseline.
How often should you check?
Run a baseline before a major theme, plugin, hosting, PHP or caching change. Repeat after deployment and whenever visitors report slowness. For sites that change frequently, scheduled synthetic checks plus field monitoring provide earlier warning than an occasional manual test. The exact cadence depends on how often the site changes and how important timely interactions are; consistency of the scenario matters more than an arbitrary frequency.
WordPress Core Performance guidance describes measurement as essential both for identifying meaningful improvements and for avoiding regressions. Treat each result as evidence for a decision, not as a permanent grade.
The Bottom Line
The reliable way to check WordPress performance is layered: Site Health for the environment, PageSpeed Insights for lab and field metrics, WebPageTest for controlled waterfalls, and profiling tools for server-side causes. Test representative URLs repeatedly, keep the setup fixed, and change one variable at a time.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
