For core web vitals ecommerce work, fix what real shoppers experience: make the main image or heading on product and category pages appear quickly (LCP), stop elements jumping while the page loads (CLS), and keep taps and clicks responsive (INP). Start with your own field data, then fix images, scripts, fonts and layout in that order.
Core web vitals ecommerce shops need: the three metrics in plain terms
- Largest Contentful Paint (LCP) measures how long it takes for the biggest visible element to render, usually the hero banner on a home page or the main product photo on a product page. It reflects whether the page looks loaded.
- Cumulative Layout Shift (CLS) measures unexpected movement. It is the reason a shopper taps "Add to basket" and instead hits something else because a banner pushed the button down.
- Interaction to Next Paint (INP) measures how quickly the page responds visually after taps, clicks and key presses throughout the visit. It replaced an earlier measure and reflects whether the page feels responsive.
Google publishes the thresholds that count as good, needs-improvement and poor on web.dev. Because they can be revised, check that page for the current values instead of memorising numbers from an article, and note the date you checked.
Reading your own data
There are two kinds of data, and mixing them up leads to wasted effort.
- Field data comes from real visitors on their real devices and connections. Search Console's Core Web Vitals report and the Chrome User Experience data used by PageSpeed Insights show this, grouped by page type. Field data is what counts.
- Lab data comes from a simulated test, such as Lighthouse. It is repeatable and good for debugging, but it uses a single device and connection profile.
Workflow: use field data to find which page groups fail (often product pages, category pages or checkout), use lab tests to find out why, then confirm in field data weeks later, since the field numbers cover a rolling period. For UK stores, mobile on a mid-range phone is the segment to look at first. If a page has too little traffic to appear in field data, rely on lab testing plus your own monitoring.
LCP: the hero image and server time
Two things make an LCP slow: the browser waits too long for the HTML, or the biggest element takes too long to arrive and draw. Check them in that order.
- Server response. Slow database queries, uncached pages and distant hosting delay everything. Use page caching for anonymous visitors, a content delivery network for static files and sensible hosting.
- Identify the LCP element. Lab tools tell you which element it is. On product pages it is generally the main photo.
- Do not lazy-load it. Lazy loading is excellent for images below the fold but harmful for the main image. Load it eagerly, and consider giving it a high fetch priority.
- Right-size and compress. Serve modern formats where supported, responsive sizes through
srcset, and never ship a huge original to a phone. - Remove render blockers. Large stylesheets and synchronous scripts in the head delay painting.
CLS: reserving space
Layout shifts happen when something arrives without space reserved for it. Common culprits on store pages:
- Images and videos without width and height attributes or an aspect ratio.
- Cookie banners, promo bars and "free delivery" notices injected above the content after load.
- Web fonts that swap in with different dimensions than the fallback.
- Reviews, recommendations and "recently viewed" widgets that load late and push content.
- Ads or third-party embeds with no reserved slot.
Fix by giving every media element dimensions, reserving fixed-height containers for late-loading blocks, overlaying banners instead of pushing content, and picking fallback fonts with similar metrics. Our note on building consent banners for UK sites covers a banner design that does not disturb layout.
INP: scripts and interactions
INP problems are almost always JavaScript keeping the main thread busy when a shopper taps. Stores accumulate scripts: analytics, chat, review widgets, personalisation, A/B testing, tag managers and marketing pixels.
- Audit every third-party script. For each, ask what it earns you and whether you can remove it, delay it until after the first interaction, or load it only on pages that need it.
- Break up long tasks, so the browser can respond between chunks of work.
- Keep handlers for filters, variant selectors and basket updates light; do the visual update first and defer the rest.
- Avoid expensive re-rendering of large product grids when a filter changes.
- Test the real interactions: open the menu, change a variant, add to basket, open the mini-basket, apply a filter.
Performance profiling in the browser's developer tools shows which scripts block interactions; fix the worst first.
Platform-specific traps
Hosted and plugin-based stores tend to fail in predictable ways, regardless of brand.
- Plugin or app sprawl: each addition brings its own scripts and styles on every page, even where unused. Remove what you do not need and load the rest conditionally.
- Heavy themes: multipurpose themes ship features you never switch on. Consider a leaner template for product pages.
- Uncached dynamic pages: basket and account pages cannot be cached the same way as catalogue pages; check that caching rules do not disable caching for everything. Our WooCommerce performance guide covers this in detail.
- Unoptimised image uploads: staff uploading full-size camera photos. Automate resizing and compression.
For mobile product-page specifics, see fast product pages on mobile, and for custom builds, our guide to fixing Core Web Vitals on custom websites.
Monitoring
Performance drifts: each new campaign tag or plugin update can undo your work. Build in a routine.
- Check Search Console's report on a regular schedule, and after every significant release or new third-party script.
- Keep a short performance budget, such as limits on page weight and number of third-party scripts, and review additions against it.
- Run lab tests on your key templates (home, category, product, basket, checkout) before releases.
- Log changes with dates so a regression can be matched to its cause.
Putting it together
Pick the worst-performing page group in your field data, find the one change likely to move it, ship it and measure again. The metrics matter because slow, jumpy stores lose shoppers, but they are a means to a better experience rather than a score to chase. If you need hands-on help, our software development team for UK businesses works remotely and can review a store's templates and scripts.
Frequently asked questions
What is INP?
Interaction to Next Paint measures how quickly a page visually responds after a visitor taps, clicks or presses a key, across the whole visit. It reflects how responsive the page feels. Poor INP usually comes from heavy JavaScript, often third-party scripts, keeping the browser busy when a shopper interacts.
Which metric should I fix first?
Fix whichever one your own field data shows failing on your most valuable page group, often product pages on mobile. In practice LCP and CLS fixes such as image handling and reserved space are usually quicker, while INP needs a script audit. Check current thresholds on web.dev.
Where do I find my data?
Use Google Search Console's Core Web Vitals report for field data grouped by page type, and PageSpeed Insights for page-level field data plus a lab test. Lighthouse in Chrome developer tools is good for debugging. Field data from real visitors is what counts, and it updates over a rolling period.