The leak no copy change can fix.
You can rewrite every headline and test every button colour, but if the page takes four seconds to load on mobile, 53% of visitors never see the work. Across the 1,200+ pages Levri has analysed, page-speed issues appear on 68% of sites - the single most common conversion leak we detect. Not bad copy, not missing trust signals. Load time.
The data is unambiguous. Deloitte and Google measured it across retail, travel, and luxury: a 0.1-second improvement in mobile load lifted retail conversions 8.4% and travel 10.1%. Portent found ecommerce conversion dropping from 3.05% at one second to 0.67% at four - a 78% decline for three extra seconds. Speed sets the ceiling everything else sits under, and it hurts most on mobile, the context behind mobile checkout optimization.
The six patterns that move load time.
- LCP (Largest Contentful Paint) over 2.5 seconds - the hero finishes rendering after patience runs out.
- Third-party script bloat - 35 invisible tags dragging the main thread.
- Unoptimised images - the payload eating 60-70% of page weight.
- Layout shift - the visual jolt that erodes trust before copy is read.
- Slow server response - the ceiling no front-end trick can lift.
- Render-blocking code - resources holding every pixel hostage.
#1 - Largest Contentful Paint over 2.5 seconds.
LCP tracks when the biggest visible element - usually your hero image or headline - finishes rendering. Google's threshold is 2.5 seconds, and only ~50% of mobile sites pass it. Every 100ms off LCP is worth roughly a 7% conversion lift; sites loading in one second see goal conversion around 39%, falling to 18% at six. Your hero is also your message, which is why your hero section matters twice over.
What we see on scans
- Hero images over 500KB in a legacy format (no WebP/AVIF).
- The LCP element loading after 15+ other resources, lacking
fetchpriority="high". - Above-the-fold images lazy-loaded by mistake.
- Custom fonts blocking headline text for 1-2 seconds.
What to ship
- Convert the hero to WebP/AVIF; target under 100KB above the fold.
- Add
fetchpriority="high"to the LCP image - one attribute, immediate impact. - Remove
loading="lazy"from anything above the fold. - Preload the primary font and add
font-display: swap.
Typical lift: +5% to +15%. Impact: high - LCP is the strongest single predictor of engagement and funnel progression.
#2 - Third-party script bloat.
The average page loads 35+ third-party scripts - analytics, chat, retargeting, replay, heatmaps - and the top ten providers block the main thread ~1.4 seconds combined. That's 1.4 seconds where the page can't respond to a tap, scroll, or keystroke. The visitor is trying to buy; your scripts are telling them to wait.
What we see on scans
- 20-40 external scripts loading synchronously in the
<head>. - Chat widgets initialising before the page is interactive.
- Multiple analytics tools tracking the same events.
- Tag managers loading other tag managers.
What to ship
- Audit every third-party script - if you can't name its revenue impact, defer or remove it.
- Move non-critical scripts to
async/defer; chat and social widgets should never block render. - Consolidate overlapping tools - you don't need four analytics platforms.
- Set a budget: no more than five synchronous third-party scripts in the
<head>.
Typical lift: +3% to +12%. Impact: high - the most common cause of poor Interaction to Next Paint, now a Core Web Vital.
#3 - Unoptimised images.
Images are 60-70% of a typical page's weight; at the 90th percentile, sites ship over 5MB per page - five seconds on a median 4G connection before a word of copy appears. Mobile pages average 8.6 seconds to load, desktop 2.5, and the gap is almost entirely image weight. This is the technical half of the image work in product page conversion.
What we see on scans
- Product images as uncompressed PNGs at 2,000px wide in a 400px container.
- No
srcset/sizes- every device downloads the desktop image. - Below-fold images loading eagerly, stealing bandwidth from above-fold content.
- Missing
width/height, causing shift as images pop in.
What to ship
- Serve everything in WebP/AVIF - modern CDNs do this automatically.
- Add responsive
srcsetso mobiles fetch a 400px image, not a 2,000px one. - Set
loading="lazy"below the fold, eager above it. - Always set
width/height(or CSSaspect-ratio) to prevent shift.
Typical lift: +4% to +10%. Impact: high - the largest single payload and the easiest to fix without touching logic.
#4 - Cumulative Layout Shift.
You go to tap "Add to cart," a banner loads above, the button drops below your thumb, and you hit "Subscribe" instead. That's CLS (Cumulative Layout Shift) - Google's threshold is 0.1 or less. Poor CLS doesn't just frustrate; it erodes trust. If the layout can't hold still, why would anyone trust you with a card?
What we see on scans
- Images and videos without explicit dimensions - the browser can't reserve space.
- Dynamically injected banners and consent pop-ups pushing content down.
- Web fonts causing a flash of unstyled text that shifts heights.
- Ad slots and embeds loading without reserved space.
What to ship
- Add
width/heightto every image and video - non-negotiable. - Reserve space for dynamic content with
min-heightor skeletons. - Use
font-display: swapwith size-adjusted fallbacks. - Don't inject above-the-fold content after render - overlay instead of pushing down.
Typical lift: +2% to +6%. Impact: medium - rarely fatal alone, but it compounds the trust erosion of other speed issues.
#5 - Server response time above 800ms.
TTFB (Time to First Byte) is the clock from request to the first byte back. Google recommends 800ms or less, and it accounts for ~40% of total LCP - so no front-end trick saves you if the server is slow. B2B (business-to-business) sites at one-second total load convert at three times the rate of five-second sites. The server sets the floor.
What we see on scans
- TTFB over 1.5 seconds on initial load.
- No CDN - every request travels to a single origin.
- Unoptimised queries adding 500ms+ to server-side rendering.
- Same-origin redirect chains (HTTP to HTTPS to www) stacking latency.
What to ship
- Deploy a CDN - static and HTML caching alone can cut TTFB 60-80%.
- Eliminate redirect chains; point internal links at the final canonical URL.
- Cache pages that don't vary per visitor (most product, landing, and blog pages).
- Profile your queries if you server-side render - one slow query taxes every load.
Typical lift: +3% to +8%. Impact: high - TTFB is the foundation every other metric sits on.
#6 - Render-blocking CSS and JavaScript.
The browser can't paint a pixel until it finishes downloading and parsing render-blocking resources. A 400KB JS bundle (1MB+ decompressed) can hold the page hostage for two seconds on a mid-range phone. Nearly 70% of consumers say speed influences their buying decision - these resources decide whether they see a blank screen or your value proposition first.
What we see on scans
- Large CSS in the
<head>containing styles for pages the visitor isn't on. - JS bundles over 300KB compressed, loaded synchronously before content.
- No code splitting - the whole app ships on every page.
- Critical CSS not inlined, forcing an extra round-trip before first paint.
What to ship
- Inline critical (above-the-fold) CSS in the
<head>; load the rest async. - Add
deferto non-essential scripts. - Implement code splitting - each page loads only the JS it needs.
- Remove unused CSS (Chrome DevTools Coverage) - most sites cut 40-60%.
Typical lift: +4% to +12%. Impact: high - the primary cause of blank-screen mobile experiences that drive instant bounces.
How Levri spots all six in 60 seconds.
Levri checks load behaviour alongside copy, trust, and funnel issues - LCP, script weight, image payload, layout shift, server response, render-blocking resources - and ranks each by estimated revenue impact.
You paste the URL, and you get your fixes - a ranked list, each issue priced in $/mo, with a written hypothesis, a variant-B suggestion, and an expected lift range. No install, no tracking script, no "connect your analytics."
Fix these first.
In the order we'd ship:
- Fix LCP - hero image format, priority, and fonts (strongest single predictor).
- Cut third-party scripts to a budget (biggest hidden main-thread cost).
- Optimise images - format, srcset, lazy-load (largest payload).
- Deploy a CDN and kill redirect chains (lift the server floor).
- Inline critical CSS and defer JS (stop the blank screen).
- Reserve space to kill layout shift (protect trust).
Speed sets the ceiling for every other change - the hero you're optimising in hero CTR (Click-through rate) can't convert if it renders late, and the images in product page conversion can't sell if they arrive after the visitor leaves. Ship three and measure by Friday; if the numbers don't move, you're optimising above a slow floor, which is exactly what Levri is built to diagnose.