Why Your CrUX Scores Differ from Lighthouse in India: A Diagnostic Guide

By Sahil Chaudhary · Last updated 20 Oct 2026

For Indian businesses targeting the diverse Bharat market, a high Lighthouse score on a fast development machine often doesn't translate to equally good Core Web Vitals (CWV) scores in Google's Chrome User Experience Report (CrUX). This discrepancy isn't merely academic; it directly impacts your Google search rankings in India and, critically, the experience of your actual users on budget Android phones and variable 4G networks across the country. Understanding this gap is the first step to truly optimising your web presence for the Indian audience.

TL;DR: CrUX field data for Indian users frequently shows poorer Core Web Vitals (LCP, INP, CLS) than Lighthouse lab scores due to slower devices and network conditions. To bridge this gap, focus on optimising for low-spec Android devices, network variability, and real-world user interactions, using CrUX data as your primary source of truth for Indian traffic.

Key takeaways

• CrUX is the Truth for India: Always prioritise CrUX field data over lab data for understanding real user experience on Indian networks and devices.
• Diagnose the Discrepancy: Understand that low-end Android devices, inconsistent 4G, and data-saver modes are primary drivers of poorer CrUX scores compared to Lighthouse.
• Optimise for the Edge: Implement strategies like aggressive image compression, network-aware loading, and client-side rendering optimisations that benefit users at the lower end of the performance spectrum.
• Track Real-World Impact: Use RUM and CrUX to continuously monitor LCP, INP, and CLS for Indian traffic, adjusting your strategy based on observed user behaviour.

Understanding CrUX vs. Lighthouse for Indian Traffic

Google's Core Web Vitals are a set of metrics that quantify the real-world user experience of loading, interactivity, and visual stability. They are a critical ranking signal for Google Search, and for businesses operating in India, understanding their performance in the Indian context is paramount.

Lighthouse provides a lab-based, synthetic measurement of your website's performance. It runs in a controlled environment, typically simulating a mid-range mobile device on a fast 4G network. While excellent for quick diagnostics and identifying potential issues, it often fails to capture the nuances of the Indian user base.

CrUX (Chrome User Experience Report), on the other hand, provides real-world field data collected from actual Chrome users. This is the data Google uses for its Page Experience ranking signal. For India, CrUX data reflects the performance experienced by users on a wide range of devices, including many budget Android phones, often with limited RAM and slower CPUs, connected via inconsistent 4G or even 2G networks in Tier-2 and Tier-3 cities.

The primary reason for the common CrUX-Lighthouse discrepancy in India is this fundamental difference in testing environments versus real user conditions. A site that scores 90+ in Lighthouse might struggle to meet the 'Good' thresholds for LCP (Largest Contentful Paint), INP (Interaction to Next Paint), and CLS (Cumulative Layout Shift) when measured against the P75 (75th percentile) of actual Indian users. Ignoring this gap means your perceived performance is likely far better than your actual user experience.

Diagnosing the Discrepancy: A Step-by-Step Guide for Indian Traffic

When your CrUX report for Indian traffic shows significantly worse CWV scores than your Lighthouse audits, follow this diagnostic process. This helps you target the real bottlenecks affecting your users.

1. Verify Your CrUX Data Source

Start with PageSpeed Insights (PSI) for your specific URLs, ensuring you're looking at the 'Field Data' section. For a broader overview, check Google Search Console's Core Web Vitals report, which aggregates origin-level CrUX data. Pay close attention to the 'Origin Summary' if your page-level data is insufficient, as it provides a holistic view of your site's performance across all pages and users.

2. Analyse LCP Discrepancies: Network & Rendering Bottlenecks for India

Root Causes in India:

• Slow TTFB on Variable Networks: High latency on 4G networks, especially outside major metros, means a longer time for the initial HTML to arrive. This can be exacerbated by server locations far from Indian users.
• Large Hero Images/Videos: Unoptimised, high-resolution hero elements are a major LCP blocker on slower networks and CPU-constrained budget devices common in India.
• Render-Blocking Resources: Heavy JavaScript bundles and unoptimised CSS delay content rendering on CPU-constrained devices, pushing back the LCP.

Diagnostic Steps:

1. Check TTFB: Use WebPageTest from an Indian location (e.g., Mumbai, Bengaluru) with a simulated slow 4G connection. A TTFB above 600ms is a red flag for LCP.
2. Identify LCP Element: In PSI, look at the 'Largest Contentful Paint element' screenshot. Is it an image, video, or large text block?
3. Analyse Resource Loading: Use Chrome DevTools' Network tab (with CPU throttling and slow 4G simulation) to see when the LCP element loads relative to other resources.

Fixes for LCP in India:

• Edge Caching & CDN: Implement a robust CDN with edge servers in India to reduce TTFB for Indian users. Consider services that cache dynamic content or use edge functions for faster responses.
• Image Optimisation: Aggressively compress and lazy-load non-critical images. Use modern formats like WebP or AVIF. Serve appropriately sized images with <img srcset> and <picture>. Crucially, preload your LCP image using <link rel="preload" fetchpriority="high" as="image" href="/path/to/lcp-image.webp">.
• Critical CSS & Defer Non-Critical JS: Extract critical CSS for above-the-fold content and inline it. Defer or asynchronously load non-critical JavaScript. Krapton Engineering can help you fix Core Web Vitals issues like these.

3. Pinpointing INP Differences: CPU & Interaction Delays on Indian Devices

Root Causes in India:

• CPU-Bound JavaScript: Complex JavaScript execution on low-end Android CPUs leads to long tasks, blocking the main thread and delaying interaction responses.
• Large Bundles & Hydration Costs: Overly large JavaScript bundles increase parsing and execution time, especially on first load and during hydration, impacting Time to Interactive (TTI) and subsequent interactions.
• Excessive Event Handlers: Too many or inefficient event listeners (e.g., on scroll, input) can trigger expensive recalculations and layout, leading to high INP.

Diagnostic Steps:

1. Simulate Low-End Device: Use Chrome DevTools' Performance tab with 4x or 6x CPU throttling and a 'Low-end mobile' device profile. Record user interactions.
2. Identify Long Tasks: Look for long tasks (red triangles) in the main thread during interactions. The 'Bottom-Up' or 'Call Tree' tabs will show the functions consuming the most time.
3. Measure Interaction Latency: Specifically measure the delay from user input to the next visual update.

Fixes for INP in India:

• Code Splitting & Lazy Loading: Break down large JavaScript bundles using dynamic imports (e.g., React.lazy(), Next.js dynamic imports). Load only what's needed for the current view.
• Debouncing & Throttling: Apply debouncing to input events and throttling to scroll events to reduce the frequency of expensive computations.
• Web Workers: Offload heavy, non-UI computations to web workers to keep the main thread free for user interactions.
• Concurrent React Features: For React applications, leverage useTransition and startTransition to mark non-urgent updates, allowing urgent UI updates (like input responses) to be prioritised.

import { useTransition, useState } from 'react';

function SearchInput() {
  const [isPending, startTransition] = useTransition();
  const [query, setQuery] = useState('');

  function handleChange(e) {
    // Urgent update for input value
    setQuery(e.target.value);

    // Non-urgent update for search results (can be deferred)
    startTransition(() => {
      // fetchSearchResults(e.target.value);
    });
  }

  return (
    <input type="text" value={query} onChange={handleChange} disabled={isPending} />
  );
}

4. Mitigating CLS Discrepancies: Visual Stability for All

Root Causes in India:

• Font Loading Issues: Slow network speeds can delay custom font loading, leading to FOUT (Flash of Unstyled Text) or FOIT (Flash of Invisible Text), causing layout shifts when the font finally renders.
• Dynamic Ad/Content Injection: Ads, banners, or third-party widgets (e.g., payment gateways, chat widgets) that inject content without reserving space can cause significant CLS, especially if they load slowly or unpredictably.
• Viewport-Dependent Layouts: Layouts that rely heavily on JavaScript to calculate dimensions after load can cause shifts if rendering is delayed, common on slower CPUs.

Diagnostic Steps:

1. Visually Inspect with Throttling: Record a page load in Chrome DevTools with CPU/network throttling. Look for sudden shifts.
2. Use Layout Shift Regions: In DevTools, go to 'Rendering' tab and enable 'Layout Shift Regions' to visually highlight areas causing shifts.
3. Check Font Loading: Observe font loading waterfall in the Network tab.

Fixes for CLS in India:

• Reserve Space for Media/Ads: Always specify width and height attributes for images, videos, iframes, and ads. For dynamic content, use CSS min-height or aspect-ratio boxes.
• Font Optimisation: Use font-display: swap; to allow text to be visible with a fallback font while the custom font loads. Preload critical fonts. Consider self-hosting fonts on your CDN for faster delivery.
• Avoid Injecting Content Above Existing Content: If dynamic content must be added, ensure it doesn't push existing content down.

When NOT to Over-Optimise for CrUX

While optimising for CrUX in the Indian context is vital, there are trade-offs. Over-optimising can sometimes lead to a degraded experience for users on high-end devices or introduce undue complexity. For instance, extremely aggressive image compression might visibly reduce image quality for users on high-resolution screens. Similarly, excessive code splitting might introduce more network requests than necessary for users on stable, fast connections, adding a slight overhead. The goal is a balanced approach: focus on the P75 percentile for Indian users, ensuring a 'Good' experience for the majority, while not penalising the top-tier users. Always test changes across a spectrum of devices and network conditions.

Leveraging Performance Budgets for Indian Markets

For D2C brands and e-commerce platforms in India, setting realistic performance budgets is crucial. Given the prevalence of budget Android phones and variable 4G, your JavaScript bundle size and image payloads need to be significantly leaner than for Western markets. A good starting point might be a JavaScript budget of 150-200KB (gzipped) and an image budget of 500KB-1MB per page for critical assets. Tools like Lighthouse CI can enforce these budgets in your CI/CD pipeline, preventing regressions before they reach production. This proactive approach ensures your site remains performant for the average Indian user, directly impacting conversion rates and bounce rates, especially during peak sales like Diwali or festive seasons.

CWV Metric	CrUX 'Good' Threshold	Common Indian Discrepancy Cause	Krapton Engineering's Focus Area
LCP (Largest Contentful Paint)	<= 2.5 seconds	Slow TTFB on variable 4G, large unoptimised hero images for low-end devices.	CDN edge caching (India-specific nodes), image pipeline optimisation (WebP/AVIF, responsive images, preload).
INP (Interaction to Next Paint)	<= 200 milliseconds	Heavy JavaScript execution on low-CPU Androids, long tasks blocking main thread.	Code splitting, lazy loading, web workers, React concurrent features (e.g., useTransition).
CLS (Cumulative Layout Shift)	<= 0.1	Slow font loading (FOUT/FOIT), dynamic ad/content injection without reserved space, especially on delayed network.	font-display: swap;, aspect-ratio boxes for media, reserving space for third-party widgets.

FAQ

How does the Digital Personal Data Protection Act 2023 impact web performance in India?

While not directly a performance metric, DPDP Act 2023 compliance can indirectly affect performance by requiring careful handling of consent banners and data collection scripts. Ensure these scripts are non-render-blocking and load efficiently to avoid impacting LCP or INP. Proper implementation of consent management platforms (CMPs) that are performant is essential for Indian businesses. This is general information and not legal advice; consult the official Digital Personal Data Protection Act 2023 as of 2026 for full details.

What role does India Stack play in Core Web Vitals optimisation?

India Stack components like Aadhaar eKYC, DigiLocker, and UPI are critical for many Indian applications. Their integration can introduce third-party script overhead. Optimise how these are loaded: defer non-critical scripts, use placeholders, and ensure the third-party integrations themselves are performant. For example, ensuring your UPI payment integration loads efficiently is crucial for a smooth user experience, especially during checkout.

Should I only target 'Good' CWV scores for Indian users?

Ideally, yes. Google's ranking signal considers the 'Good' threshold. While 'Needs Improvement' is better than 'Poor', striving for 'Good' ensures your site is competitive and provides a superior experience for the majority of your Indian audience. This commitment translates directly into better SEO and higher engagement, especially for D2C brands, leading to improved conversion rates and customer loyalty.

Boost Your Site's Performance for Indian Users

Improving your Core Web Vitals for the unique challenges of the Indian market is not just an SEO task; it's a fundamental investment in your user experience and business growth. By focusing on real-world CrUX data and optimising for the diverse device and network landscape in India, you ensure your digital presence is robust and competitive. Don't let the gap between Lighthouse and CrUX hold your business back. Run a free SEO audit with Krapton's SEO Analyzer today to diagnose your site's LCP, INP, and CLS scores instantly and take the first step towards a better user experience for your Indian customers.

About the author

Krapton Engineering is the dedicated team behind Krapton's web, mobile, and AI software development. We architect and build high-performance, scalable solutions, focusing on robust frontend and backend systems that excel in challenging global and local markets, including India's unique digital landscape.