Frequently Asked Questions

What Are Core Web Vitals?

Core Web Vitals are a set of real-world performance metrics defined by Google that measure key aspects of user experience on the web. They form part of Google’s Page Experience signals, which directly influence search rankings. First introduced in 2020 and incorporated into Google’s ranking algorithm in 2021, Core Web Vitals have become a practical requirement for any agency delivering CMS websites — not just a technical nicety.

The three Core Web Vitals metrics are Largest Contentful Paint (LCP), Cumulative Layout Shift (CLS), and Interaction to Next Paint (INP). Each measures a different dimension of user experience, and each has a defined threshold for ‘Good’, ‘Needs Improvement’, and ‘Poor’ ratings. A site must score ‘Good’ on all three metrics for at least 75% of real-world visits to be considered passing.

The Three Core Web Vitals Metrics Explained

Largest Contentful Paint (LCP)

LCP measures loading performance. Specifically, it records the time from when a user first navigates to a page to when the largest visible content element — typically a hero image, a large text block, or a video poster — is fully rendered. A ‘Good’ LCP score is 2.5 seconds or less. Between 2.5 and 4 seconds is ‘Needs Improvement’. Above 4 seconds is ‘Poor’.

LCP is the metric most directly tied to the subjective feeling of a page loading quickly. It is the first impression users have of a site’s speed, and it is frequently the Core Web Vital that agencies find hardest to optimise on poorly built CMS sites. Slow server response times, unoptimised images, render-blocking resources, and poorly configured hosting are the most common causes of a poor LCP score.

Cumulative Layout Shift (CLS)

CLS measures visual stability. It quantifies how much the page layout unexpectedly shifts during loading — for example, when a font loads and pushes content down, or when a late-loading image causes the page to reflow. A ‘Good’ CLS score is 0.1 or less. Between 0.1 and 0.25 is ‘Needs Improvement’. Above 0.25 is ‘Poor’.

CLS is a user experience issue as much as a technical one. Pages with high CLS are frustrating to read — content jumps around as the page loads, causing users to lose their place or accidentally click the wrong element. For CMS websites in particular, layout shifts are often introduced by embedded content, injected ads or cookie banners, web fonts, and lazy-loaded images without reserved dimensions.

Interaction to Next Paint (INP)

INP replaced First Input Delay (FID) as a Core Web Vital in March 2024. It measures responsiveness — specifically, the latency between a user’s interaction (a click, a tap, or a keyboard press) and the next visual response from the page. A ‘Good’ INP score is 200 milliseconds or less. Between 200ms and 500ms is ‘Needs Improvement’. Above 500ms is ‘Poor’.

INP is directly affected by the amount of JavaScript executing on the main thread. Heavy plugin loads, large JavaScript bundles, and inefficient front-end code are the primary culprits for poor INP scores on CMS websites.

Platform-Specific Impacts

Different CMS platforms have inherently different Core Web Vitals characteristics, and agencies need to understand these differences to set appropriate expectations with clients and to brief development partners correctly.

• WordPress: WordPress sites have a wide range of Core Web Vitals performance depending on how they are built. A well-optimised WordPress site built with a lightweight theme, a good caching plugin, and a CDN can achieve excellent scores. However, the plugin ecosystem is WordPress’s biggest vulnerability — many popular plugins, including page builders like Elementor and Divi, add significant JavaScript and CSS payloads that hurt LCP and INP. Agencies must insist on performance-first development practices for WordPress projects.
• Headless CMS: Headless CMS implementations paired with a modern JavaScript front end (Next.js, Nuxt.js, Astro) typically achieve the best Core Web Vitals scores. Pre-rendering, CDN delivery, and optimised JavaScript bundles give these sites a structural performance advantage. For clients where performance is a commercial priority, headless architecture is the strongest recommendation.
• Drupal: Drupal is a capable platform for performance when configured correctly, but it has a complex caching layer that requires specialist knowledge to optimise properly. Core Web Vitals performance on Drupal sites varies significantly based on the theme, module selection, and server configuration.
• Shopify and E-Commerce Platforms: Shopify has invested heavily in its performance infrastructure, but app integrations and complex Liquid templates can introduce performance regressions. Agencies delivering Shopify builds should audit third-party apps carefully and test Core Web Vitals before and after integration.

Common CMS Causes of Poor Core Web Vitals Scores

Regardless of platform, the following are the most frequent technical causes of poor Core Web Vitals scores on CMS websites.

• Unoptimised Images: Images that are not compressed, not served in next-generation formats (WebP or AVIF), not lazy-loaded correctly, or not sized appropriately for their display dimensions are the single most common cause of poor LCP scores. The CMS must support and enforce image optimisation — either natively or through a plugin.
• No Caching Layer: Uncached CMS pages require a database query and server-side rendering on every visit. Without page caching and object caching (via Redis or Memcached), even modestly trafficked sites can produce slow server response times (TTFB) that directly damage LCP.
• Render-Blocking Resources: JavaScript and CSS files loaded in the document head that block rendering are a primary cause of poor LCP. Development partners should defer or asynchronously load non-critical scripts and inline critical CSS.
• Excessive Plugin or Module Loads: Every active WordPress plugin or Drupal module adds server-side processing and often additional front-end resources. A site with 40 active plugins is almost guaranteed to have performance issues unless each has been audited for its impact.
• No Content Delivery Network (CDN): Serving static assets (images, scripts, stylesheets) from the origin server rather than a CDN increases latency for users who are geographically distant from the hosting infrastructure.
• Cumulative Layout Shift from Fonts and Embeds: Web fonts that don’t specify fallback metrics, embedded third-party content without defined dimensions, and dynamically injected banners are common sources of CLS.
• Heavy JavaScript Execution: Large JavaScript bundles — particularly from page builders, analytics scripts, chat widgets, and marketing automation tools — slow down main thread execution and produce poor INP scores.

What Agencies Should Require From Development Partners

Agencies are commercially accountable for the performance of the websites they deliver, even when the technical work is done by a white label partner. Core Web Vitals scores are measurable, public, and directly linked to client outcomes. Agencies should therefore set clear performance standards in their partner agreements.

• Minimum Score Thresholds: Specify that all delivered sites must achieve ‘Good’ Core Web Vitals scores (LCP under 2.5s, CLS under 0.1, INP under 200ms) for at least 75% of visits, as measured by Google PageSpeed Insights and Chrome User Experience Report data.
• Pre-Launch Performance Testing: Require that the development partner runs PageSpeed Insights, Lighthouse, and WebPageTest against all key pages before launch and provides a performance report with the project handover documentation.
• Image Optimisation Standards: Mandate that all images are served in WebP or AVIF format, lazy-loaded below the fold, and sized correctly for their display dimensions. The hero/LCP image should be preloaded.
• Caching Configuration: Require documented server-side caching configuration (page cache, object cache, CDN) for all WordPress and Drupal projects.
• Plugin/Module Audit: For WordPress projects, require a pre-launch plugin audit that identifies any plugin with a measurable performance impact and confirms there is no lighter-weight alternative.
• Ongoing Monitoring: Include Core Web Vitals monitoring in any retainer agreement. Google Search Console provides ongoing field data; supplementary tools like SpeedVitals or Calibre can provide more granular monitoring.

Agencies that make Core Web Vitals a formal requirement in their development standards position themselves as performance-aware partners — a meaningful differentiator in a market where many agencies still treat page speed as an afterthought.