How to Identify Slow Pages That Are Losing Mobile Conversions

Learn how to cross-reference Core Web Vitals data, conversion rates, and mobile behavior to find pages that drive traffic but waste real financial opportunities.

Remountly TeamPerformance Engineering and CRO

July 22, 202610 min read

Performance

Executive brief

Key takeaways

Lab data (Lighthouse) does not reflect the real experience of mobile users with restricted CPUs and unstable connections.
It is possible to calculate Revenue Leak by segmenting users by LCP and INP buckets and comparing conversion rates.
Only pages with high purchase intent and valid statistical volume should be prioritized for surgical diagnosis.
Excessive JavaScript is the primary offender for INP on mobile due to main thread bottlenecks on mid-tier devices.

Mobile traffic accounts for, on average, more than 60% of accesses for most e-commerce and B2B SaaS companies. However, the conversion rate in these sessions is often around half of that observed on desktops. Historically, this difference is attributed to the "nature of the device" or "research journeys." Although the intent may be different, a vast portion of this loss is not behavioral in origin, but strictly technical.

For results-driven operations, this scenario is not an inevitability; it is an engineering problem that can be measured, isolated, and fixed. Slow pages in the mobile environment are actively destroying your conversion rate, creating what we call a revenue leak in scenarios where traffic grows, but opportunities do not appear.

This comprehensive guide details a rigorous, data-driven methodology to cross-reference user experience metrics (Core Web Vitals), conversion behavior, and device processing capabilities, allowing you to stop optimizing "for Google" and start fixing what is effectively stealing money from your operation.

The first strategic mistake technical and marketing teams make when auditing mobile performance is blindly trusting Lighthouse (lab data).

A high Lighthouse score does not mean a healthy site. The lab environment emulates a Moto G4 or equivalent device under static conditions. It is useful for catching regressions during the deployment process, but it is incapable of predicting the impact of fluctuating 3G connections in transit, the user's processor thermal throttling, or the real latency of third-party integrations.

To diagnose conversion problems, you must use Field Data (Real User Monitoring - RUM). As explored in the article about the difference between field data and lab data, the Chrome User Experience Report (CrUX) and custom RUM libraries are the only single source of truth.

The Asymmetry of Devices (Device Tiering)

A web page is, fundamentally, a package of instructions distributed for remote execution. The client's ability to execute that package determines the experience.

Premium CPUs (e.g., iPhone 15 Pro, Galaxy S24 Ultra): Execute complex JavaScript threads quickly. Rarely expose severe Interaction to Next Paint (INP) bottlenecks.
Mid/Low-Tier CPUs (The vast majority of global mobile traffic): Have smaller L2/L3 caches and aggressive thermal limitations. The execution time of the same script can be 3 to 5 times longer.

When diagnosing mobile conversion drops, your focus is not the premium device connected to corporate Wi-Fi, but the user on the mid-tier device on unstable 4G, who tries to click the "Buy" button and experiences an interface freeze, resulting in abandonment.

2. The Analysis Architecture: Building the Evidence

To audit a site guided by evidence, it is not enough to look at pre-made reports. We need an architecture that connects the user's session with their performance experience millisecond by millisecond.

The foundation of this analysis requires three data pillars:

The Business Metric: Conversion Rate, Revenue Per Session (RPS), or Lead Generation.
The Operational Segment: Device (Mobile), Specific URL, Traffic Source.
The Technical Metric (Web Vitals): LCP (Largest Contentful Paint), CLS (Cumulative Layout Shift), and INP (Interaction to Next Paint).

Step 1: Implementing RUM in Google Analytics 4 (GA4)

To cross-reference technical performance with financial conversion, technical data needs to exist in the same database as your transactions. Native GA4 integration with Search Console is insufficient because it does not allow for granular segmentation by conversion event vs. individual landing page performance.

The surgical solution is to implement the standard web-vitals.js library and fire custom events to GA4 whenever a Core Web Vitals metric is resolved in the user's browser.

Implementation Code (JavaScript via GTM or Hardcoded):

import {onLCP, onINP, onCLS} from 'web-vitals';

function sendToGoogleAnalytics({name, delta, value, id, attribution}) {
  // Convert values for GA4 suitability. LCP/INP come in milliseconds.
  const eventParams = {
    value: Math.round(name === 'CLS' ? delta * 1000 : delta), 
    metric_id: id,
    metric_value: value,
    metric_delta: delta,
    debug_target: attribution.largestShiftTarget || attribution.interactionTarget || ''
  };

  // Dispatch to gtag.js (adjust for dataLayer if using GTM)
  if (typeof gtag !== 'undefined') {
    gtag('event', `cwv_${name}`, eventParams);
  }
}

// Configuration with detailed attribution enabled for advanced debugging
onCLS(sendToGoogleAnalytics, {reportAllChanges: true});
onLCP(sendToGoogleAnalytics, {reportAllChanges: true});
onINP(sendToGoogleAnalytics, {reportAllChanges: true});

By running this script on your site, you will start having events like cwv_LCP populated in GA4, tied to the client_id and the session_id.

Step 2: Exporting to Google BigQuery

GA4 has severe cardinality limitations and does not allow for complex cross-referencing of numerical metrics in the standard interface. It is imperative that GA4 data is exported to BigQuery daily. Once the export is active, you have the necessary database to discover slow pages bleeding conversions.

3. Surgical SQL Queries: Isolating the Revenue Leak

With the data in BigQuery, the goal is to answer a clear question: "On pages with high commercial intent accessed via mobile, how does the conversion rate behave when LCP is classified as Good (<=2.5s) versus Poor (>4.0s)?"

This is the principle for understanding the invisible cost of the mobile experience in B2B and B2C companies. The correlation between Core Web Vitals performance and revenue only becomes undeniable when statistically proven in your own data.

The Definitive Performance Segmentation Query

Below is a BigQuery standard SQL instruction model to classify mobile traffic by loading bucket and tie it to conversions (e.g., purchase or generate_lead event).

WITH session_performance AS (
  SELECT
    user_pseudo_id,
    (SELECT value.int_value FROM UNNEST(event_params) WHERE key = 'ga_session_id') AS session_id,
    event_date,
    device.category AS device_category,
    (SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'page_location') AS landing_page,
    MAX(IF(event_name = 'cwv_LCP', (SELECT value.int_value FROM UNNEST(event_params) WHERE key = 'value'), NULL)) AS lcp_ms
  FROM
    `your_project.analytics_123456789.events_*`
  WHERE
    device.category = 'mobile'
    AND event_name = 'cwv_LCP'
  GROUP BY 1, 2, 3, 4, 5
),

session_conversions AS (
  SELECT
    user_pseudo_id,
    (SELECT value.int_value FROM UNNEST(event_params) WHERE key = 'ga_session_id') AS session_id,
    MAX(IF(event_name = 'purchase', 1, 0)) AS converted,
    SUM(IF(event_name = 'purchase', (SELECT value.float_value FROM UNNEST(event_params) WHERE key = 'value'), 0)) AS revenue
  FROM
    `your_project.analytics_123456789.events_*`
  WHERE
    event_name = 'purchase'
  GROUP BY 1, 2
),

joined_data AS (
  SELECT
    p.landing_page,
    p.lcp_ms,
    CASE 
      WHEN p.lcp_ms <= 2500 THEN 'Good'
      WHEN p.lcp_ms > 2500 AND p.lcp_ms <= 4000 THEN 'Needs Improvement'
      WHEN p.lcp_ms > 4000 THEN 'Poor'
      ELSE 'Unknown'
    END AS lcp_bucket,
    IFNULL(c.converted, 0) AS is_converted,
    IFNULL(c.revenue, 0) AS total_revenue
  FROM session_performance p
  LEFT JOIN session_conversions c 
    ON p.user_pseudo_id = c.user_pseudo_id AND p.session_id = c.session_id
  WHERE p.lcp_ms IS NOT NULL
)

SELECT
  landing_page,
  lcp_bucket,
  COUNT(*) as total_mobile_sessions,
  SUM(is_converted) as total_conversions,
  ROUND((SUM(is_converted) / COUNT(*)) * 100, 2) as conversion_rate_percent,
  SUM(total_revenue) as total_revenue
FROM joined_data
GROUP BY 1, 2
HAVING total_mobile_sessions > 100
ORDER BY landing_page, lcp_bucket;

Interpreting the Evidence

By running this query, you will generate a cross-table. Look for patterns where the conversion_rate_percent in the "Good" row (LCP <= 2.5s) is massively higher than the "Poor" row (LCP > 4s) for the same landing_page.

If the page https://example.com/product-a has:

Mobile "Good" LCP Traffic: 3.2% Conversion
Mobile "Poor" LCP Traffic: 1.1% Conversion

You have found an offender. The next step is to calculate the impact. Multiply the sessions in the "Poor" bucket by the conversion rate of the "Good" bucket and subtract the current conversions. The result is exactly how much money that slow page is stealing from your business weekly.

4. The Impact of Client-Side Rendering (CSR) on Conversion

Many modern companies build their sites as Single Page Applications (SPAs) or with heavy client-side hydration using React, Vue, or similar frameworks. On mobile, this creates a critical problem: JavaScript rendering severely affects SEO and paralyzes the user's ability to interact with the page.

When evaluating conversion, LCP (Largest Contentful Paint) is just the first challenge. The user sees the product image, but the page continues executing megabytes of JavaScript in the background to initialize state, hooks, and components. When the user tries to tap the "Buy" button on a mobile device with reduced processing power, the Main Thread of the browser is blocked.

This block generates a high INP (Interaction to Next Paint), signaling to the user that the site "froze." In B2C contexts, a 400ms delay in response to a tap can be enough for the user to abandon the flow, assuming the button or the site as a whole does not work reliably.

It is crucial to diagnose INP surgically using the "Performance" tabs in Chrome DevTools. If a page demonstrates high abandonment, record a Performance Profile in DevTools with the "CPU Throttling: 4x slowdown" and "Network Throttling: Fast 3G" options enabled. This accurately simulates the mobile bottleneck and reveals Long Tasks that would not occur on a powerful desktop.

5. How to Identify Hidden Opportunity Structures

You have cross-referenced your analytical data. You have located the URLs with the worst LCP and INP on mobile devices. You have found that they present lower conversion rates compared to users who load them quickly.

The systematic identification step requires prioritization:

Step 1: Filter by the Traffic Curve

Not every slow page needs immediate optimization. An institutional page with 50 monthly accesses that takes 6 seconds to load is not a significant financial problem. Apply a minimum threshold for impressions/sessions using your reports and focus on the Top 10% of URLs that drive qualified traffic.

Step 2: The "Time to First Byte" (TTFB) Factor

Before engaging Frontend teams to refactor components, investigate the weight of the infrastructure. Diagnosing the impact of TTFB on web performance may reveal that the server's initial response time (such as generating slow HTML or heavy database queries) already consumes half of your LCP budget. If the server takes 2 seconds to respond on mobile, it is mathematically impossible to achieve a "Good" LCP (< 2.5s).

Check Cache headers (Cache-Control: public, max-age=...), CDN infrastructure, and optimize slow database queries on the backend before changing a line of CSS.

Step 3: Evaluating Render-Blocking Resources

In the unstable mobile environment, every HTTP request counts. When the browser starts parsing the HTML of your Landing Page and finds <script> or <link rel="stylesheet"> tags in the <head> without the defer or async attributes, it pauses DOM construction.

Evidence: Open the "PageSpeed Insights" report, go to the "Diagnostics" section, and observe the "Eliminate render-blocking resources" metric.
Action: Use conditional inlining for critical above-the-fold CSS and change the priority order of less essential files, a fundamental technique for diagnosing and resolving LCP problems.

6. Automating Mobile Evidence Collection

Mature engineering teams do not investigate performance reactively; they monitor continuously. The official CrUX API allows you to pull real mobile performance data from millions of users directly into your dashboards in market intelligence tools or via Python orchestration scripts.

By extracting massive data via API for dozens of URLs (according to your sitemap), you can integrate technical observation with tools like Looker Studio, Grafana, or Supabase and permanently cross-reference with financial reports.

Practical Python Extraction Example using the CrUX API:

import requests
import json
import os

# Insert your Google API Console key with CrUX API permission
API_KEY = os.environ.get('GOOGLE_API_KEY')
CRUX_URL = f"https://chromeuxreport.googleapis.com/v1/records:queryRecord?key={API_KEY}"

def get_crux_data_for_mobile(url):
    payload = {
        "record": {
            "url": url
        },
        "formFactor": "PHONE",
        "metrics": ["largest_contentful_paint", "interaction_to_next_paint", "cumulative_layout_shift"]
    }
    
    headers = {"Content-Type": "application/json"}
    response = requests.post(CRUX_URL, headers=headers, json=payload)
    
    if response.status_code == 200:
        data = response.json()
        record = data.get('record', {})
        metrics = record.get('metrics', {})
        
        # Extracting P75 (75th Percentile - Google's official standard)
        lcp_p75 = metrics.get('largest_contentful_paint', {}).get('percentiles', {}).get('p75')
        inp_p75 = metrics.get('interaction_to_next_paint', {}).get('percentiles', {}).get('p75')
        
        return {
            "url": url,
            "device": "PHONE",
            "LCP_ms": lcp_p75,
            "INP_ms": inp_p75
        }
    else:
        print(f"Error fetching {url}: {response.text}")
        return None

# Target list of high conversion pages
target_urls = [
    "https://example.com/checkout",
    "https://example.com/products/gamer-laptop-xyz",
    "https://example.com/main-campaign-landing-page"
]

results = []
for url in target_urls:
    data = get_crux_data_for_mobile(url)
    if data:
        results.append(data)
        print(f"URL: {data['url']} | LCP: {data['LCP_ms']}ms | INP: {data['INP_ms']}ms")

# From here, you can persist in a DB and cross-reference with GA4 conversion rates.

This automation, running bi-weekly or weekly, acts as an early warning system. If the LCP of the main checkout page rises from 1800ms to 3500ms on PHONE (Mobile), the technical team is notified before marketing notices the systematic drop in leads at the end of the month.

7. From Observation to Action: The Final Surgical Diagnosis

Once slow and low-converting mobile URLs have been isolated, and the damage validated by cross-referenced models, the engineering team or outsourced consultants are no longer fighting for abstract points in an SEO tool. They are leading the closure of a revenue leak.

Root Cause Triage in 3 Steps:

What is stalling the initial screen? (LCP Images and Critical CSS): Open the Chrome Performance tab (throttled). If the cause of the delay is the visual LCP, closely audit initial rendering optimization tactics. Giant images in responsive carousels not adjusted for the mobile viewport destroy conversion. Add fetchpriority="high" to the main image, and correctly use the srcset and sizes attributes to serve compatible, lower-resolution .webp or .avif formats.
What disorients the user? (Layout Shifts): Unexpected layout shifts make users click the wrong links, generating tremendous frustration and an increase in Bounce Rate. Insert reserved width and height in HTML tags for dynamic banners, AdSense blocks, and product recommendation integrations, stabilizing the metrics.
What paralyzes client actions? (Main Thread Blocking - INP): INP captures the response of every tap, click, or keydown throughout the entire lifespan of the session, not just the beginning. Reduce the indiscriminate use of Google Tag Manager tags with redundant triggers. Use requestIdleCallback to separate non-essential Third-party Scripts (e.g., online support chat, Facebook pixel) to times when the browser is not calculating layout or heavy animations.

Conclusion and Validation Guidelines

Identifying slow pages that ruin mobile conversion metrics requires managers to cross knowledge barriers: from Technical Web Performance to Data Analysis and Consumer Behavior.

Your validation will occur by observing the "Mobile Conversion Rate" metric over the weeks following the optimization (ideally with an A/B Isolation Test on the Edge Network).

To conclude:

The definitive evidence is in field data. Lighthouse only guides, CrUX API data or RUM libraries determine the truth.
Every performance delay in B2B Mobile and E-commerce carries a financial signature tied to low engagement. Use BigQuery/SQL database reports to expose this reality to your company's C-Level.
Don't assume your team understands user latency; unless they emulate Fast 3G with 4x CPU Slowdown, they are operating blind.

Keep diagnosing. Keep measuring. Web performance is a lasting competitive commercial advantage.

Direct answers

Frequently asked questions

Why does my site load fast on 5G, but mobile conversion remains low?

Because the bottleneck is usually not just the network, but processing power. Mid-tier devices take up to 4 times longer to execute the same JavaScript as a flagship iPhone, freezing interaction and hurting INP (Interaction to Next Paint).

Should I analyze all the pages on my site?

No. Filter your pages by organic and paid session volume and focus on those with clear commercial intent (product pages, checkout, lead forms).

Can I use native Google Analytics 4 (GA4) to measure the impact of slowness on conversion?

Yes, but the native integration is limited. The most accurate method involves capturing Core Web Vitals via web-vitals.js and sending them as custom events to GA4, then analyzing them via BigQuery.