Insights / Development
Core Web Vitals for business web applications: measure what your users actually feel
Core Web Vitals turn 'this feels slow' into three numbers: loading, interactivity, and layout stability. What each means, where business apps lose the points, and the fixes in order.
Kiran Bandarupalli · 14 Nov 2026 · 5 min read

Ask a user whether your application is fast and you will get an answer in feelings, not milliseconds: pages feel sluggish, buttons feel dead, the layout jumps just as they tap the wrong thing. Core Web Vitals turn those feelings into three numbers you can measure, compare, and improve — Largest Contentful Paint, Interaction to Next Paint, and Cumulative Layout Shift. They are Google's field metrics, collected from real Chrome users, and they feed into search ranking. For a business application they matter for a simpler reason: every slow page is a form abandoned or a checkout delayed.
This post explains what each metric actually measures, how to read your own numbers, and where business applications usually lose the points — and in what order to fix them.
The three metrics, in plain terms
Each metric answers one question a user is really asking.
- Largest Contentful Paint (LCP) — “Is it loaded yet?” How long until the largest visible piece of content renders: the hero image, the headline, the main product photo. Good is under 2.5 seconds. LCP is usually decided by the server response, the hero asset, and whatever is blocking the render before it.
- Interaction to Next Paint (INP) — “Did it hear me?” How long the page takes to respond after a click, tap, or keypress. Good is under 200 milliseconds. INP is the “dead button” metric: the click registered, but nothing visibly happened because the main thread was busy running JavaScript.
- Cumulative Layout Shift (CLS) — “Did it just move?” How much visible content shifts after it first appears: the banner that loads late and pushes the form down, the font that swaps and reflows the text. Good is under 0.1. CLS is the metric users notice most directly, because it makes them tap the wrong thing.
These are field metrics — measured on real users' devices and networks, not your office connection. A page that loads in a second on your laptop can take five on a mid-range phone on a slow connection — and the field number is the one that counts.
Measure the field first, the lab second
Lab tools such as Lighthouse and PageSpeed Insights run the same page the same way every time, which makes them excellent for catching regressions in CI — but they simulate a device on a simulated network. Field data, from the Chrome UX Report or your own real-user monitoring snippet, is what your users actually experience, and it is what Google ranks on.
Start with PageSpeed Insights on your five most-visited pages and write the three numbers down. If a page has no field data, it does not have enough traffic for Chrome to report on — fix it by the lab numbers and check again in a month, because field data lags by roughly 28 days. The same discipline applies to the parts of the application users never see directly: observability for asynchronous workflows is how you know whether the slow part is the page, the queue, or the job behind it.
Where business applications usually lose the points
The same handful of causes shows up in almost every audit.
- Images served at full camera resolution. A 4 MB photo displayed at 400 pixels wide is the single most common LCP problem. Serve the size that is displayed, in a modern format, and you have often fixed half the page. The same care applies when users supply the images: secure image uploads covers validating the bytes, stripping metadata, and serving safely — the resizing step in that pipeline is also a performance step.
- JavaScript that blocks the main thread. One large bundle, a chat widget, and three analytics tags can keep the main thread busy for seconds. That is an INP problem first and an LCP problem second, because the browser cannot paint while it is parsing your code.
- A slow server response. Time to first byte is the floor under LCP: nothing renders before the server answers. A database that opens a new connection per request is a classic cause — MySQL connection pooling explains why, and the fix is usually a pool and an index, not a bigger server.
- Fonts and late-loading banners that shift the layout. A web font that swaps in after the fallback font has already laid out the page moves every line of text. A cookie banner or announcement bar injected late moves everything below it. Both are CLS, and both are fixed by reserving the space before the content arrives.
- Third-party scripts that compete for the main thread. Every widget you embed is code you did not write running on your user's device. Audit them once a quarter; remove the ones nobody can name the owner of.
Fixes, ordered by impact
Start with the change that moves the worst metric on the worst page. For most business applications the order is: server response, hero image, main-thread JavaScript, layout stability, everything else.
<!-- Tell the browser what matters first -->
<link rel="preload" href="/fonts/inter.woff2" as="font" type="font/woff2" crossorigin>
<link rel="preconnect" href="https://cdn.example.com">
<img src="/images/hero-800.jpg"
srcset="/images/hero-800.jpg 800w, /images/hero-1600.jpg 1600w"
sizes="(max-width: 640px) 100vw, 50vw"
width="1600" height="900"
fetchpriority="high" alt="Team dashboard showing live performance metrics">
Three details in that snippet do real work. The width and height attributes reserve the image's space before it loads, removing its layout shift entirely. The srcset lets the browser pick the size that matches the screen instead of downloading the desktop image on a phone. And fetchpriority="high" tells the browser the hero image is the LCP element, so it is fetched before the images below the fold.
A starting checklist
- Record LCP, INP, and CLS for your five most-visited pages, from the field where it exists and the lab where it does not.
- Set explicit width and height on every image, video, and embed.
- Serve images at the size displayed, in a modern format, with the hero image preloaded.
- Defer non-critical JavaScript, split the bundle, and audit third-party scripts quarterly.
- Keep server response under 600 ms on the pages that matter; pool database connections instead of opening one per request.
- Preload the critical font and reserve space for banners and ads so nothing shifts after paint.
- Cache static assets with a long expiry and compress responses with Brotli.
- Write the numbers into performance budgets for the work users actually see, and fail the build when a change breaks one — a budget that nobody enforces is a wish.
On mobile the same numbers are harder to hit and easier to feel: a slow connection and a weaker device punish every extra kilobyte twice. The other half of the mobile story is what happens when the network disappears entirely — offline-first mobile apps and sync conflicts.
Core Web Vitals are not a score to chase for its own sake. They are a shared language for what your users already tell you in plain words: this feels slow, this moved when I tried to tap it. Measure the three numbers, fix the worst one on the worst page, and measure again. If performance work keeps losing to feature work, our custom software team can take it on as a defined piece of work — talk to us and we will start with the audit.