WordPress speed optimization: a 47-point checklist

Use this checklist in order of evidence

This 47-point checklist is a working audit for WordPress sites. It does not promise a particular load time or score: hosting, content, visitor devices and business requirements differ. Start with the failing user experience, choose the relevant checks, and verify one class of change at a time.

Prioritize measured bottlenecks before advanced server tuning. A change that saves a small request but breaks checkout is a regression, even if a lab score improves.

Establish the baseline

1. Choose representative home, article, archive, product and checkout URLs; include signed-in and anonymous sessions.
2. Record hosting region, device, network conditions, browser and release version so later runs are comparable.
3. Run repeatable lab tests more than once and retain the range, not just the fastest result.
4. Check real-user LCP, INP and CLS where field data is available; distinguish URL data from origin data.
5. Inspect the document request and separate DNS, connection and server-response delay.
6. Capture a main-thread trace while reproducing the slow interaction, not only during initial load.
7. Identify the actual LCP element and the request chain needed to display it.
8. Save a restorable backup and define the key user flows that must still work after changes.

Reduce origin work

9. Use a supported PHP release compatible with the site; validate upgrades in staging before production.
10. Check OPcache health and capacity. Do not disable timestamp checks unless deployment explicitly invalidates the cache.
11. Profile slow PHP paths and repeated database queries before changing server settings.
12. Review remote API requests in page rendering; use appropriate caching and bounded timeouts.
13. Check persistent object caching with the host and verify invalidation when content changes.
14. Cache public HTML only where safe; bypass authenticated, cart, checkout and personalized responses.
15. Confirm that two different users cannot receive one another’s cached data.
16. Inspect CPU, memory and worker saturation under representative load before increasing concurrency.
17. Validate scheduled task execution. If moving WP-Cron to a system scheduler, monitor missed and failed jobs.
18. Inspect query plans before adding indexes; assess write overhead and test on a representative data copy.
19. Review oversized autoloaded options with their owning plugin. Back up before targeted cleanup.
20. Paginate large queries and avoid loading an unbounded collection into memory.

Improve rendering and interaction

21. Remove unused scripts and styles only after checking menus, forms, checkout and editor requirements.
22. Defer compatible scripts while preserving dependency order; async is not a substitute for ordered execution.
23. Inspect render-blocking styles. Test any critical-CSS approach across templates and viewport sizes.
24. Keep the LCP image discoverable in the initial HTML instead of inserting it late with JavaScript.
25. Do not lazy-load the LCP image. Use high fetch priority selectively, then inspect the waterfall.
26. Break expensive JavaScript into measured chunks and yield between them when appropriate.
27. Batch layout reads and writes to avoid repeated forced layout.
28. Remove unnecessary third-party widgets; delay optional ones only when their behavior and consent rules permit.
29. Reserve dimensions for images, embeds and advertisements before their resources arrive.
30. Check font fallback metrics and layout shifts; use font-display deliberately.
31. Keep interactive controls usable with keyboard navigation and reduced motion.
32. Test long pages and low-powered devices; a fast homepage does not prove every template is fast.

Deliver appropriately sized assets

33. Choose an image width for its rendered slot and expected pixel density.
34. Compare AVIF, WebP and existing formats on the actual asset rather than assuming a fixed saving.
35. Provide responsive srcset candidates and a sizes value that reflects the layout.
36. Lazy-load off-screen images and use asynchronous decoding where appropriate.
37. Keep essential labels and explanations as HTML; small text inside images is difficult to read.
38. Self-host or otherwise minimize font requests; load only weights and character sets the site needs.
39. Preload only truly critical assets after verifying the request waterfall.
40. Check gzip or Brotli delivery for text assets and avoid recompressing already compressed images.
41. Use long-lived caching for versioned static assets and change their URL when their content changes.
42. Load video intentionally. Hiding a video with CSS alone does not guarantee its download stops.

Verify the release

43. Test login, search, contact forms, cart and checkout after enabling any optimization.
44. Inspect cache headers and content invalidation on edited pages.
45. Repeat baseline lab tests with the same conditions and record both gains and regressions.
46. Monitor field metrics over time; a release is not immediately reflected in a rolling data window.
47. Set performance budgets and keep a change log so a later regression can be traced to a release.

Sources and further reading

• WordPress: Optimization
• Google: Optimize LCP
• Google: Optimize INP

Keep exploring

Dig into TTFB and Core Web Vitals diagnosis and responsive image delivery.