A WordPress website can look great and still provide a poor experience if visitors have to wait several seconds for pages to load.
Performance affects much more than a PageSpeed score. A slow website can frustrate visitors, reduce conversions and make a site feel less professional.
When I work on WordPress performance, I don’t start by installing several optimization plugins and hoping for a better score. I first identify what is actually slowing the website down and then optimize each area carefully.
In this article, I’ll explain the process I use when working on WordPress website performance and Core Web Vitals.
1. Start With a Proper Performance Audit
Before changing anything, I establish a baseline.
I normally test important pages such as the homepage, service pages, landing pages, product pages and other high-traffic pages.
Some of the things I look for include:
- Largest Contentful Paint (LCP)
- Interaction to Next Paint (INP)
- Cumulative Layout Shift (CLS)
- Time to First Byte (TTFB)
- Total page size
- Number of requests
- Large or unoptimized images
- Render-blocking resources
- Unnecessary JavaScript
- Third-party scripts
- Font loading
- Server response time
I also test both desktop and mobile.
A website that performs well on a powerful desktop connection can behave very differently on a mobile device.
Tools such as PageSpeed Insights and Chrome DevTools help identify the symptoms, but the important part is determining what is causing them.
2. Optimize the Largest Contentful Paint
LCP measures how quickly the main visible content of a page appears.
On many WordPress websites, the LCP element is the hero image, banner, featured image or large heading near the top of the page.
When LCP is poor, I check areas such as:
Hero images: Large hero images should be properly resized and compressed rather than uploading a 4K image and displaying it at a much smaller size.
Image format: Where appropriate, I use modern formats such as WebP.
Lazy loading: Images below the fold can benefit from lazy loading, but the primary above-the-fold image should not be unnecessarily delayed.
Server response: Even perfectly optimized images cannot completely compensate for a server that takes too long to begin returning the page.
CSS and fonts: Important content can also be delayed while the browser waits for stylesheets or fonts.
The goal isn’t simply to make the image smaller. It is to make the important above-the-fold content available to the browser as early as possible.
3. Optimize Images Properly
Images are one of the most common performance problems I find on WordPress websites.
A website may display an image at 800 pixels wide while loading an original file several thousand pixels wide.
My normal image workflow includes:
- resizing images to appropriate dimensions;
- compressing them before or during upload;
- using WebP where suitable;
- serving responsive image sizes;
- lazy-loading below-the-fold images;
- avoiding unnecessarily large background images.
I also check whether the website is loading the correct WordPress-generated image size.
The objective is simple: don’t make the visitor download pixels they will never see.
For image-heavy websites, this alone can make a noticeable difference.
4. Reduce Unnecessary CSS and JavaScript
WordPress websites often accumulate CSS and JavaScript from themes, page builders and plugins.
The problem becomes worse when plugins load their assets across the entire website even though they are only required on one or two pages.
I review what the browser is loading and look for:
- unused plugin scripts;
- unnecessary CSS;
- duplicate libraries;
- render-blocking resources;
- scripts that can safely be deferred;
- third-party scripts that load too early.
However, optimization needs to be done carefully.
Aggressively combining, delaying or removing JavaScript can break menus, sliders, forms, WooCommerce functionality or Elementor interactions.
For me, a working website with a slightly lower score is always better than a broken website with a perfect synthetic score.
5. Keep Elementor Pages Efficient
Elementor Pro is capable of producing excellent websites, but page structure still matters.
When working with Elementor, I try to keep the layout clean rather than creating unnecessary containers inside containers.
I pay attention to:
- container structure;
- unnecessary widgets;
- duplicated styling;
- global typography and colors;
- responsive settings;
- background images;
- animations and motion effects;
- custom fonts;
- third-party Elementor add-ons.
If a simple section can be built with a few native Elementor widgets, I generally don’t install another addon package containing dozens of widgets just to use one feature.
Fewer dependencies usually mean an easier website to maintain and optimize.
6. Configure Caching Correctly
Caching is an important part of WordPress performance, but it should complement good optimization rather than hide underlying problems.
Depending on the hosting environment, caching can include:
Page caching to serve pre-generated pages instead of processing the entire WordPress request repeatedly.
Browser caching to allow static files to remain stored on a visitor’s device for an appropriate period.
Object caching for websites where repeated database operations can benefit from it.
CDN caching to distribute static resources closer to visitors in different geographic regions.
The exact setup depends on the hosting stack.
I avoid installing multiple caching plugins that perform overlapping functions. That can create conflicts and make troubleshooting more difficult.
7. Review Plugins and Theme Overhead
A large number of plugins does not automatically mean a website will be slow.
The more important question is what those plugins are doing.
One poorly optimized plugin can cause more problems than several lightweight plugins.
I review plugins for:
- unnecessary frontend assets;
- expensive database queries;
- duplicate functionality;
- excessive background processes;
- external API calls;
- features that are no longer being used.
If two plugins perform essentially the same task, I consider whether one can be removed.
I also check the active theme and child theme for unnecessary functionality or custom code that could affect performance.
8. Clean and Optimize the WordPress Database
Over time, WordPress databases can accumulate data that is no longer particularly useful.
Examples can include:
- post revisions;
- expired transients;
- old plugin data;
- orphaned metadata;
- unnecessary autoloaded options;
- temporary WooCommerce data.
Database cleanup should never be treated as simply pressing Delete All.
Before making significant database changes, I take or verify a backup.
I then identify what can safely be cleaned without affecting the website.
For larger WordPress and WooCommerce websites, database performance becomes increasingly important as the site grows.
9. Optimize Fonts
Fonts are easy to overlook.
A website may load several font families with multiple weights even though only a few are actually used.
I check:
- how many font files are loaded;
- which weights are really necessary;
- whether fonts are loaded locally or externally;
- whether important fonts should be preloaded;
- whether the browser has an appropriate fallback.
For example, loading Regular, Medium, SemiBold and Bold can make sense.
Loading eight or nine weights of multiple font families when the design uses only three of them usually does not.
10. Be Careful With Third-Party Scripts
Sometimes the slowest resources aren’t coming from WordPress at all.
Common examples include:
- analytics;
- advertising scripts;
- chat widgets;
- embedded videos;
- maps;
- social media embeds;
- tracking pixels;
- booking systems.
Some are necessary for the business, so simply deleting everything isn’t a realistic solution.
Instead, I determine whether a script needs to load immediately or whether it can be loaded later without hurting functionality.
This is particularly important for pages where conversion tracking, booking systems or ecommerce integrations are required.
11. Improve CLS by Preventing Unexpected Movement
Cumulative Layout Shift measures unexpected visual movement while a page is loading.
You’ve probably experienced this yourself: you are about to click something, then an image loads and suddenly the button moves.
Common causes include:
- images without defined dimensions;
- dynamically injected content;
- late-loading fonts;
- banners;
- embeds;
- animations that affect layout.
I try to reserve the necessary space before those elements finish loading.
A stable page feels faster and more polished even when its actual load time hasn’t changed dramatically.
12. Don’t Optimize Only for a Score
This is one of the most important parts of my approach.
A PageSpeed score is useful, but 100/100 is not the actual business objective.
I care more about:
- whether the website feels fast;
- whether important content appears quickly;
- whether interactions are responsive;
- whether the layout remains stable;
- whether forms and ecommerce features work correctly;
- whether the experience is good on mobile;
- whether the optimization is maintainable.
A website should not lose useful functionality just to gain a few points in a testing tool.
Performance optimization is about balancing speed, functionality, design and maintainability.
My WordPress Performance Checklist
Before considering an optimization project complete, I normally review:
- Hosting/server response
- WordPress and PHP environment
- Theme performance
- Plugin usage
- Image sizes and compression
- WebP implementation
- LCP element
- CLS issues
- JavaScript execution
- CSS delivery
- Font loading
- Page caching
- Browser caching
- CDN configuration
- Database health
- Third-party scripts
- Mobile responsiveness
- Forms and interactive functionality
- WooCommerce functionality where applicable
- Core Web Vitals after optimization
I then test the website again rather than assuming the changes worked.
Final Thoughts
WordPress performance optimization is rarely about one magic setting.
A fast website is usually the result of many smaller improvements working together: good hosting, optimized images, sensible page structure, efficient assets, proper caching and careful control of third-party scripts.
More importantly, every website is different.
The optimization strategy that works for a small Elementor portfolio may not be appropriate for a large WooCommerce store.
That’s why I prefer to measure first, identify the real bottlenecks, optimize them carefully and test again.
The final goal is not simply a green performance score.
It’s a WordPress website that feels fast, works reliably and provides a better experience for real visitors.