Optimise Third-Party Scripts for India CWV: Boost Speed & Rankings

By Sahil Chaudhary · Last updated 28 Oct 2026

In India's dynamic digital landscape, a website's speed directly impacts its success, from D2C brands to enterprise solutions. With a vast user base accessing the internet on diverse devices and variable 4G networks, particularly in Tier-2 and Tier-3 cities, every millisecond counts. Essential third-party scripts – for UPI payments, Aadhaar eKYC, analytics, or advertising – often introduce hidden performance bottlenecks that derail Core Web Vitals (CWV) scores, affecting both user experience and Google search rankings.

TL;DR: This guide offers Indian founders, CTOs, and product leaders a diagnostic-first runbook to identify and optimise third-party scripts impacting Core Web Vitals, specifically addressing challenges posed by India's unique digital ecosystem and user behaviour. You'll gain practical, step-by-step strategies to improve LCP, INP, and CLS for your Indian audience.

Key takeaways

• Third-party scripts are a major, often overlooked, contributor to poor Core Web Vitals scores on Indian websites due to network latency and device constraints.
• Prioritise lazy loading, strategic resource hints, and web workers to mitigate the impact of external dependencies like payment gateways and ad networks.
• Understand the trade-offs between third-party functionality, performance, and regulatory compliance, particularly with the Digital Personal Data Protection Act 2023.
• Regularly audit and verify fixes using a combination of lab data (Lighthouse) and crucial field data (CrUX) for real-world Indian user performance.
• Krapton Engineering offers specialised CWV audits and optimisation services tailored for the Indian market, focusing on practical, measurable improvements.

Why Third-Party Scripts Impact India's Core Web Vitals

Core Web Vitals – Largest Contentful Paint (LCP), Interaction to Next Paint (INP), and Cumulative Layout Shift (CLS) – are critical metrics for Google's Page Experience signal. For Indian businesses, these metrics are particularly challenging due to:

• Network Variability: From urban fibre to rural 4G, connection speeds are inconsistent. Third-party scripts, often hosted on distant servers, add significant latency.
• Budget Android Devices: A large segment of India's internet users rely on entry-level Android smartphones with limited processing power and RAM. Heavy JavaScript from third-parties can easily overwhelm these devices, leading to long tasks and unresponsive interactions.
• Specific Script Types: Indian websites heavily integrate payment gateways (Razorpay, PayU, Paytm), Aadhaar-based eKYC solutions, logistics trackers, and localised ad networks. Each injects its own CSS, JavaScript, and often, additional network requests, creating a complex dependency chain.

LCP suffers when third-party scripts block the main thread, delaying the rendering of the largest content element. INP deteriorates as complex third-party JavaScript monopolises the main thread, delaying user interaction responses. CLS often occurs when third-party ads or widgets dynamically inject content without reserving space, shifting existing page elements.

Diagnosing Third-Party Performance Bottlenecks

Effective optimisation begins with accurate diagnosis. For Indian websites, it’s crucial to look beyond simple lab scores and consider real user data.

1. PageSpeed Insights & Lighthouse: Start with these tools to get a lab-based overview. Pay close attention to diagnostics like "Reduce JavaScript execution time," "Eliminate render-blocking resources," and "Avoid large layout shifts." The "Third-Party Usage" section highlights specific domains contributing to delays.
2. Chrome DevTools:
• Network Tab: Filter by domain to identify slow-loading third-party scripts. Look for long TTFB (Time To First Byte) for external resources.
• Performance Tab: Record a page load or user interaction. Analyse the Main thread activity. Long tasks (red triangles) often point to third-party JavaScript blocking rendering or interaction.
• Coverage Tab: Identify unused CSS and JavaScript, especially from third-party libraries, that can be deferred or removed.
3. WebPageTest: Provides detailed waterfall charts and visual progress, helping to pinpoint exactly when third-party requests initiate and complete, and their impact on rendering. Test from a Mumbai or Bengaluru server location to simulate Indian user conditions more accurately.
4. CrUX Field Data: For a true picture of performance for your Indian audience, monitor your Core Web Vitals scores in Google Search Console (under "Core Web Vitals" report). This real-user data (CrUX) reflects actual user experiences on various devices and networks across India, which often differs significantly from lab scores.

Strategies to Optimise Third-Party Scripts for Indian Users

1. Lazy Load Non-Critical Scripts

Not all scripts are essential for the initial page render. Prioritise what the user sees first.

• async and defer Attributes: These are your first line of defence. Use async for independent scripts (like analytics) that don't depend on or block other scripts. Use defer for scripts that need to execute in order but aren't critical for initial rendering (e.g., chat widgets, consent management platforms).
• Intersection Observer: For widgets or ads below the fold, load them only when they enter the viewport. This is particularly effective for reducing initial load burden on budget Android devices.

<!-- Defer a chat widget script -->
<script src="https://chat.example.com/widget.js" defer></script>

<!-- Async for non-blocking analytics -->
<script src="https://analytics.example.com/script.js" async></script>

<!-- Lazy load an ad below the fold using Intersection Observer -->
<div id="ad-container" data-src="https://ads.example.com/ad.js"></div>
<script>
  const adContainer = document.getElementById('ad-container');
  const observer = new IntersectionObserver((entries, observer) => {
    entries.forEach(entry => {
      if (entry.isIntersecting) {
        const script = document.createElement('script');
        script.src = adContainer.dataset.src;
        document.body.appendChild(script);
        observer.unobserve(adContainer);
      }
    });
  });
  observer.observe(adContainer);
</script>

2. Self-Host or Cache Where Possible

While not always feasible due to licensing or dynamic content, self-hosting static third-party resources can eliminate DNS lookups and reduce network latency.

• Fonts and Small Libraries: If a third-party font or a small JavaScript library is critical and licensed for redistribution, self-hosting on your own CDN (e.g., AWS CloudFront, Google Cloud CDN) can significantly improve LCP.
• CDN Caching: Ensure your CDN configuration aggressively caches static third-party assets at edge locations close to your Indian users. This reduces the TTFB for subsequent requests.

When NOT to over-optimise: Do not self-host scripts that require frequent updates (e.g., payment gateway SDKs with evolving security patches) or those explicitly forbidden by their terms of service. Security vulnerabilities from outdated self-hosted scripts can be far more detrimental than a minor CWV hit.

3. Optimise Payment Gateway and Authentication Flows

Indian businesses heavily rely on seamless payment and authentication. These integrations are often performance-heavy.

• Preconnect for Critical Domains: For payment gateways or Aadhaar eKYC providers, use <link rel="preconnect"> to establish early connections. This saves valuable milliseconds when the user initiates a transaction.
• Load On Demand: Only load payment gateway scripts or Aadhaar authentication SDKs when the user reaches the checkout page or specifically clicks an "Authenticate with Aadhaar" button. Avoid loading them on every page.
• Client-Side Validation: Perform basic form validation on the client-side before invoking the payment gateway's script. This reduces unnecessary network requests for invalid inputs.

Compliance Note: When integrating payment gateways, ensure adherence to RBI guidelines, especially regarding payment data localisation. For Aadhaar eKYC, follow UIDAI regulations and the Digital Personal Data Protection Act 2023 (DPDP Act). This is general information, not legal advice; consult legal counsel for specific compliance needs.

4. Manage Ad and Analytics Scripts

Ad networks are notorious for causing CLS and INP issues. Analytics scripts can also add significant overhead.

• Reserve Space for Ads: Use CSS aspect-ratio or fixed dimensions for ad slots and iframes to prevent layout shifts when ads load.
• Delay Non-Essential Analytics: Load non-critical analytics scripts (e.g., heatmaps, session recordings) with a delay or after user interaction, especially for users on slower networks.
• Consent Management Platforms (CMPs): CMPs are crucial for DPDP Act compliance but can be render-blocking. Ensure your CMP is optimised for performance, perhaps by loading its core logic with defer and displaying the UI after initial content.

5. Use Web Workers for CPU-Intensive Tasks

Web Workers allow you to run JavaScript in a background thread, offloading heavy computations from the main thread. This significantly improves INP, especially on lower-end Android devices where the main thread is easily saturated.

• Use Cases: Complex data processing, image manipulation, heavy encryption/decryption tasks often found in secure authentication modules, or even pre-rendering parts of a complex UI.
• Implementation: Move CPU-bound third-party code (if it doesn't need DOM access) into a Web Worker.

// main.js
if (window.Worker) {
  const myWorker = new Worker('worker.js');
  myWorker.postMessage({ data: 'some heavy computation input' });
  myWorker.onmessage = function(e) {
    console.log('Message received from worker:', e.data);
    // Update UI with results without blocking main thread
  };
} else {
  // Fallback for browsers that don't support Web Workers
  console.warn('Web Workers not supported. Performing computation on main thread.');
}

// worker.js
self.onmessage = function(e) {
  const result = e.data.data.toUpperCase(); // Heavy computation example
  self.postMessage(result);
};

6. Implement Resource Hints (Preconnect, Preload, Prefetch)

Resource hints tell the browser what resources it will need in the near future, allowing it to prioritise fetching them.

For Indian users, preconnecting to critical third-party domains can shave off hundreds of milliseconds from LCP due to high network latency.

Hint Type	Purpose	When to Use for Third-Parties	Example
preconnect	Establish early connection (DNS, TCP, TLS) to another origin.	For critical third-party domains (payment gateways, analytics, CDNs) that your page *will* connect to.	<link rel="preconnect" href="https://payments.example.com">
dns-prefetch	Perform DNS lookup for another origin.	For non-critical third-party domains that your page *might* connect to, as a fallback for preconnect.	<link rel="dns-prefetch" href="https://ads.example.com">
preload	Fetch a resource early in the page loading process.	For critical third-party CSS or JavaScript files that are essential for the initial render.	<link rel="preload" href="https://cdn.example.com/critical.js" as="script">
prefetch	Fetch a resource that might be needed for a future navigation.	For resources on subsequent pages (e.g., checkout page assets from a payment gateway).	<link rel="prefetch" href="/next-page-assets.js">

Verifying Your Core Web Vitals Fixes

Optimisation is an iterative process. After implementing changes, it's crucial to verify their impact, especially on real Indian users.

• Re-test with PageSpeed Insights & Lighthouse: Run new audits to see immediate improvements in lab scores. Look for reductions in JavaScript execution time, fewer render-blocking resources, and better CLS scores.
• Monitor CrUX Field Data: This is the ultimate test. It takes time (typically 28 days for new data to accumulate), but observe your Core Web Vitals report in Google Search Console. Look for improvements in your 75th percentile scores for LCP, INP, and CLS for mobile users in India.
• Real User Monitoring (RUM) Tools: Integrate RUM solutions (e.g., Sentry, Datadog RUM, or custom implementations with web-vitals.js) to continuously track performance metrics for your actual user base. This helps identify regressions and provides granular insights into performance across different devices, networks, and geographies within India.

For complex web applications, particularly SaaS development, continuous monitoring and iterative improvements are key to maintaining high CWV scores for a diverse user base. Krapton Engineering applies these rigorous diagnostic and verification processes to all client engagements, ensuring sustained performance gains.

FAQ

Why do my Lighthouse scores differ from CrUX for Indian users?

Lighthouse provides lab data under ideal, simulated conditions, while CrUX reflects real-world performance from actual users across India. Indian users often have slower networks and budget devices, leading to lower CrUX scores than your fast-laptop Lighthouse tests.

Can I remove Google Analytics to improve CWV?

While removing analytics can slightly improve CWV by reducing script load, it's generally not recommended due to the loss of crucial user behaviour data. Optimise it by using async, deferring its load, or using a lightweight alternative if data collection needs are minimal.

How does the DPDP Act 2023 affect third-party script management?

The Digital Personal Data Protection Act 2023 mandates explicit consent for processing personal data. Third-party scripts, especially analytics and ad trackers, often collect personal data. You must ensure your Consent Management Platform (CMP) is compliant and that scripts are only loaded after valid consent, potentially impacting initial load performance.

What's the best way to load UPI payment scripts?

The best approach is to load UPI payment gateway scripts on demand, typically when a user initiates a transaction on the checkout page. Use <link rel="preconnect"> for the payment gateway's domain early on, but defer the script execution until it's absolutely necessary to minimise impact on initial LCP and INP.

Krapton's Approach to Core Web Vitals Optimisation in India

At Krapton Engineering, we understand that optimising Core Web Vitals for the Indian market requires a nuanced approach, blending deep technical expertise with an understanding of local user behaviour and infrastructure challenges. Our senior engineers conduct comprehensive CWV audits, focusing specifically on how third-party scripts, network conditions, and device limitations impact your website's performance across India. We don't just identify problems; we implement practical, measurable solutions that improve LCP, INP, and CLS, ensuring your website offers a superior experience and achieves higher search rankings. Ready to fine-tune your website's performance for the Indian market? Book a free consultation with Krapton's Core Web Vitals experts. We'll help diagnose and resolve your third-party script performance issues, ensuring an optimal experience for your users across India.

About the author

Krapton Engineering is the team behind Krapton's innovative web, mobile, and AI software solutions, specialising in building high-performance, scalable platforms and optimising complex web applications for global and Indian audiences.