Skip to content
ROI Synth

Website speed and Core Web Vitals optimization

Website speed optimization, measured through Core Web Vitals, improves three user experience measures that Google reports on: Largest Contentful Paint (loading), Interaction to Next Paint (responsiveness) and Cumulative Layout Shift (visual stability). The work starts with field data from real users and fixes root causes rather than chasing lab scores.

By ROI SynthUpdated 11 min read

The problem this solves

Google uses Core Web Vitals as part of its page experience signals, but has said that great page experience does not override relevance. The stronger case for the work is usually commercial: slow, unstable pages frustrate visitors and reduce conversions.

Teams often optimize for a lab score on a fast development machine while real users on mid-range phones experience something very different. Fixes made without diagnosis, such as adding lazy loading to the hero image, can make metrics worse.

What the work includes

  • Field data review from the Chrome UX Report and Search Console
  • Template-level diagnosis of LCP element, long tasks and layout shifts
  • Recommendations for images, fonts, scripts, third-party tags and caching
  • Performance budgets for future development

How the work is done

  1. Start with field data

    Identify which templates fail which metric for real users, on which devices.

  2. Diagnose in the lab

    Reproduce problems with throttled profiling to find the specific resources and scripts responsible.

  3. Fix by impact

    Address the largest causes first, often image delivery, render-blocking resources and heavy third-party scripts.

  4. Wait for field data

    Field data reflects a rolling window of real visits, so confirm improvements over the following weeks.

When real visitors feel what your lab scores hide

A woman using a laptop navigating a contemporary data center with mirrored servers

Core Web Vitals work is worth doing when real people on real devices are having a slower, jumpier experience than your team sees on its own laptops. That gap is common on coded sites. Developers test on fast machines and fast connections; many customers browse on mid-range phones over mobile data, often with a dozen marketing scripts loading alongside your code.

Search Console's Core Web Vitals report and the Chrome UX Report show what real visitors experience, grouped by page type. If important templates are marked as needing improvement or poor, or if your conversion rate on mobile trails desktop by more than your market explains, the work usually pays for itself in experience before any search effect is considered.

  • Search Console flags groups of URLs as poor for LCP, INP or CLS on mobile.
  • The hero image or headline appears noticeably late on a phone.
  • Buttons respond sluggishly after the page appears, especially on listing or product pages.
  • Content jumps as fonts, banners, cookie notices or ads load.
  • A tag manager has grown to dozens of tags that nobody has audited recently.

What each metric measures, and what usually breaks it

The three Core Web Vitals each describe a different moment of a visit. Treating them separately matters, because the fixes are different and a change that helps one can hurt another. Google publishes thresholds for each, assessed at the 75th percentile of real page loads, so a page passes only when most visitors have a good experience — not just the lucky ones.

Core Web Vitals on coded websites
MetricWhat it measuresUsual causes on coded sites
Largest Contentful Paint (LCP)How long until the main content element is shownHero image lazy-loaded or oversized; content waiting for client-side data; slow server response
Interaction to Next Paint (INP)How quickly the page responds to taps, clicks and key pressesLarge JavaScript bundles hydrating at once; heavy third-party scripts; expensive re-renders
Cumulative Layout Shift (CLS)How much visible content moves unexpectedlyImages without dimensions; late-loading banners; web fonts swapping with different metrics

In frameworks like Next.js many of the right tools exist already — image components that reserve space, font loading with fallback metrics, server components that ship less JavaScript. The problems usually come from how they were used, or bypassed, in specific templates.

Field data first, then the profiler

High-resolution close-up of HTML code displayed on a computer screen, perfect for technology themes

We start with field data because it tells us which templates fail which metric for which devices. Only then do we reproduce the problem in the lab, with a throttled CPU and network that resemble a mid-range phone, to find the specific resource, script or component responsible.

This order prevents wasted effort. Lab tools happily report dozens of opportunities, many of which do not affect real users. Field data tells us which of them matter. A typical finding is narrow and concrete: the product template's LCP element is a carousel image loaded by JavaScript after hydration; rendering the first slide as a server-side image with priority loading moves it into the initial HTML.

  • Template by template

    Field data grouped by page type, because most performance problems belong to a template, not to individual URLs.

  • Real device conditions

    Profiles recorded under throttling that reflects your audience's devices, not the developer's workstation.

  • Third parties weighed honestly

    Each external script's cost measured and set against its business value, so decisions about removing or deferring it are informed.

  • Build output reviewed

    Bundle sizes per route checked, so large dependencies loaded on pages that never use them are visible.

The fixes that usually matter most

Every site is different, but on coded marketing and ecommerce sites the high-impact fixes repeat often enough to list. We implement them in your repository, measure them on a preview deployment, and then confirm the effect in field data once enough real visits have accumulated.

  • Serving the main image at the right size, in a modern format, with priority loading and reserved dimensions.
  • Moving content that search engines and visitors need first into server-rendered HTML.
  • Splitting large client bundles so each route loads only what it uses.
  • Deferring or removing third-party tags that do not justify their cost, with your agreement on each.
  • Loading fonts with matched fallback metrics so text does not jump.
  • Reserving space for banners, embeds and consent notices before they appear.
  • Caching static pages at the edge so server response time stays low worldwide.

Why results take a few weeks to confirm

Fixes can be shipped quickly; proving them takes longer. Field data in the Chrome UX Report and Search Console is based on a rolling 28-day window of real visits, so the full effect of a change appears gradually over the following weeks. Low-traffic templates may not have enough visits to report at all, in which case we rely on lab measurements under consistent conditions and say so.

Typical sequence
WhenWhat happensEvidence
Week 1Field data reviewed by template and device; worst templates profiledDiagnosis with the responsible resources named
Weeks 2–3Highest-impact fixes implemented and measured on preview deploymentsBefore-and-after lab measurements
Week 4Fixes released; performance budget added to the build where usefulChanges linked in the progress sheet
Weeks 5–10Field data watched as the rolling window updatesShare of good page loads per template

What the report shows

The headline measure is the share of real page loads meeting the good threshold for each metric, per template, on mobile and desktop separately. Alongside it we report what was changed, the lab evidence for each change, and — where analytics allows — engagement and conversion on the improved templates.

We do not report a single performance score as success. A lab score can rise while real users see no difference, or fall on a new test run for reasons unrelated to your site. Field data from your actual visitors is the measure that counts.

A hypothetical product template, diagnosed

Take a hypothetical furniture retailer whose product pages fail LCP and INP on mobile in field data, while desktop passes comfortably. The team has already compressed images and added a CDN, and the lab score on a developer laptop looks fine.

Profiling under mid-range phone conditions tells a more specific story. The largest element is the main product photo, but it sits inside a gallery component that only renders after the page's JavaScript has loaded and hydrated, so the browser cannot start fetching it early. The page also loads a reviews widget, a chat widget, two analytics tags and a recommendation script, all competing for the main thread at the moment the visitor first tries to tap the colour selector.

The fixes follow directly. The first gallery image is rendered on the server as a plain image with explicit dimensions and high fetch priority, and the interactive gallery takes over after load. The reviews widget loads when the reviews section scrolls into view rather than at startup. The chat widget loads after the first interaction. The colour selector's handler is simplified so it no longer re-renders the entire page. Each change is measured on a preview deployment, and the field data is then watched over the following weeks to confirm real visitors see the difference.

What to check on common coded stacks

Modern frameworks ship good performance defaults, and most problems come from working around them. These are the checks we run first, by stack.

First checks by framework
StackCheck firstWhy
Next.js App RouterWhich components are marked client-side, and whyUnnecessary client components inflate the JavaScript every visitor downloads
Next.js imagesPriority and sizes on the largest image of each templateA lazy-loaded hero image delays LCP on every page of that type
React single-page appsHow much renders before data arrivesBlank shells push LCP back behind network requests
Astro and islandsHow many islands hydrate on loadSeveral eager islands can recreate the cost of a full app
Any stackTag manager contents and load orderThird-party tags are often the largest single cost on the main thread

What we need from you

Performance work touches decisions only you can make. Is the chat widget worth what it costs on every page? Does marketing still use the heatmap tool installed two years ago? Can the homepage carousel become a single strong image? We measure the cost of each element and present the trade-off; you decide.

We also need repository access to implement fixes, a preview environment where changes can be measured before release, and Search Console access for field data. If your analytics can segment conversions by device, that helps us show whether performance changes are reaching the people who buy.

Governing the scripts nobody owns

On many marketing sites the biggest performance cost is not the site's own code but the scripts added around it: analytics, advertising pixels, heatmaps, chat, consent banners, A/B testing, review widgets and social embeds. Each was added for a reason. Few were ever removed, and together they often outweigh the application.

We list every third-party script with what it costs — bytes downloaded, main-thread time, effect on interaction — and who in the business relies on it. That turns an argument about performance into a business decision. Some scripts are essential and stay, loaded as efficiently as possible. Some can load later, after the page is usable. Some turn out to have no owner and can go.

  • Load non-essential scripts after the page becomes interactive, or on first interaction.
  • Load embeds such as videos and maps only when they scroll into view, with a lightweight placeholder.
  • Consolidate overlapping tools that measure the same thing.
  • Set a simple rule for adding new tags: an owner, a purpose and a review date.

The deliverables, listed

At the end of the work you hold more than faster pages. You hold the means to keep them fast.

  • Template diagnosis

    For each failing template, the metric, the device type, the cause and the evidence.

  • Implemented fixes

    Changes in your repository, each linked in the progress sheet with before-and-after lab measurements.

  • Third-party register

    Every external script with its cost, owner and loading strategy.

  • Performance budget

    Limits on script size or similar checks added to your build, where your workflow supports it.

What a performance budget looks like in practice

A performance budget is a small set of limits your team agrees to keep: for example, a maximum amount of JavaScript per route, a maximum size for the main image on each template, and no new third-party script without a named owner. Checked automatically during builds where possible, it turns performance from a periodic clean-up into a normal part of shipping features, and it gives developers a clear, objective reason to question additions that would slow the site.

How performance work connects to the rest

Performance problems often surface during a technical SEO audit, which places them alongside crawling and indexing issues so they can be prioritised together. On stores, the heaviest templates are usually listing and product pages, so the work overlaps with category page optimization and product page optimization, where image galleries, filters and review widgets live.

Performance is also one of the strongest arguments made during website redesign SEO: a redesign is the cheapest moment to choose lighter components and fewer third-party scripts. When a site is rebuilt from scratch, speed is designed in from the start and then measured on the finished pages rather than retrofitted.

Which offer includes Core Web Vitals work

Core Web Vitals work is part of the SEO offer, from $200 per month, and of All-in-One SEO + AEO + GEO, from $300 per month. On a site with one or two problem templates it can be completed within a month alongside other SEO work; on a large application with many templates and heavy third-party dependencies it runs over several months, as the written scope sets out.

If performance problems are built into the platform — a page builder that ships megabytes of script on every page — the Next.js + TypeScript Website Build, from $1,000 one time, is often the cleaner answer. Speed is then designed in and measured on the finished site rather than retrofitted.

Common questions about performance work

Honest answers to what teams usually ask first.

  • "Will passing Core Web Vitals improve our rankings?"

    It can help, but Google has been clear that relevance matters more. The stronger case is usually visitors staying, reading and enquiring.

  • "Can you guarantee a loading time?"

    No. Real loading time depends on devices and connections we do not control. We measure honestly and report what real visitors experience.

  • "Do we have to remove our marketing tags?"

    Only if you decide their cost outweighs their value. We measure each and let you choose.

  • "Our score is good in Lighthouse already"

    Then check field data. Lab scores on a developer machine often hide what mid-range phones experience.

How progress is evaluated

  • Share of page loads meeting the 'good' thresholds for each metric, by template
  • Search Console Core Web Vitals report status over time
  • Conversion rate and engagement on improved templates

Who this is for

  • Sites failing Core Web Vitals on important templates
  • Sites with heavy third-party scripts or tag managers
  • Teams wanting performance budgets in their workflow

Limits and honest caveats

Common questions

What is website speed and Core Web Vitals optimization?

Website speed optimization, measured through Core Web Vitals, improves three user experience measures that Google reports on: Largest Contentful Paint (loading), Interaction to Next Paint (responsiveness) and Cumulative Layout Shift (visual stability). The work starts with field data from real users and fixes root causes rather than chasing lab scores.

What does a website speed and Core Web Vitals optimization engagement include?

The work includes field data review from the Chrome UX Report and Search Console, template-level diagnosis of LCP element, long tasks and layout shifts, recommendations for images, fonts, scripts, third-party tags and caching and performance budgets for future development.

What problems does website speed and Core Web Vitals optimization solve?

Teams often optimize for a lab score on a fast development machine while real users on mid-range phones experience something very different. Fixes made without diagnosis, such as adding lazy loading to the hero image, can make metrics worse.

How is website speed and Core Web Vitals optimization carried out?

It runs in 4 stages: start with field data, diagnose in the lab, fix by impact and wait for field data. Identify which templates fail which metric for real users, on which devices.

Who is website speed and Core Web Vitals optimization a good fit for?

It suits sites failing Core Web Vitals on important templates, sites with heavy third-party scripts or tag managers and teams wanting performance budgets in their workflow.

How do you measure the results of website speed and Core Web Vitals optimization?

Progress is measured with share of page loads meeting the 'good' thresholds for each metric, by template, Search Console Core Web Vitals report status over time and conversion rate and engagement on improved templates.

What are the limits of website speed and Core Web Vitals optimization?

Better Core Web Vitals do not guarantee better rankings. Low-traffic pages may not have enough field data to report.

Can ROI Synth carry out the website speed and Core Web Vitals optimization work, or only recommend it?

Implementation is included. Within the agreed scope we fix templates, metadata, internal links and redirects, and build the landing pages ourselves, on your existing platform or on a Next.js and TypeScript build when a rebuild is part of the project, starting with steps such as “Field data review from the Chrome UX Report and Search Console”. Every completed item is recorded with evidence in a weekly progress sheet.

How long does website speed and Core Web Vitals optimization take?

The 4 stages (start with field data, diagnose in the lab, fix by impact and wait for field data) fit the proposal's four weekly phases. When the agreed scope can be delivered in a month, the proposal commits to completing it in the first month, subject to timely access and approvals. Search engines then take weeks or months to re-evaluate the changes.

Is website speed and Core Web Vitals optimization guaranteed to bring more traffic or leads?

No. Rankings, traffic, leads and sales depend on search engines, competition and your market, so they are not guaranteed. What is committed is the agreed work, completed and evidenced, and measurement of share of page loads meeting the 'good' thresholds for each metric, by template and Search Console Core Web Vitals report status over time.

Sources and further reading

Contact us about Website speed and Core Web Vitals optimization

Tell us about your website and goals. We will say plainly whether this is the right offer, what it would include, and what it can and cannot achieve.

Prefer the full contact page?

Fields marked with an asterisk are required.

Your website's situation, the services and markets you want to grow, and any deadlines. Up to 5,000 characters.

Your details are used only to respond to this general enquiry. See the privacy policy.

Discuss website speed and Core Web Vitals optimization for your business

Tell us about your website and goals. We will confirm whether this work is the right priority, what it would include and how it would be delivered.