The "Remove Apps" Myth
Search "how to improve Shopify speed score" and you'll find the same advice everywhere: remove apps. It's the lazy answer to a nuanced problem — and it's costing merchants real money.
Here's why it's bad advice: apps generate revenue. Your review app drives social proof and conversions. Your upsell app increases AOV. Your email capture app builds your list. Your analytics app tells you what's working. Removing them to chase a vanity metric is like unplugging your cash register to save on electricity.
The merchants who actually hit 90+ scores with real, functioning stores don't do it by removing apps. They do it by optimizing how those apps load. That's a fundamentally different approach — and it's what we're going to cover here.
We've worked with stores running 15-25 apps that score 85-95 on desktop and 70-85 on mobile. The pattern is always the same: the apps themselves aren't the problem. The way their scripts load is.
Important caveat: "Don't remove apps" doesn't mean "keep everything." If you have 3 different review apps or a popup tool you installed once and never configured, those should go. The point is: don't sacrifice functionality that drives revenue just because a speed test told you to. For a full understanding of how scores work, read our guide to what's a good Shopify speed score.
What Actually Slows Your Shopify Speed Score Down
Your Shopify speed score is calculated using Google Lighthouse, which measures six metrics. Understanding which ones apps actually affect tells you exactly where to focus:
| Metric | Weight | App Impact | Fix |
|---|---|---|---|
| Total Blocking Time (TBT) | 30% | Very High | Defer app scripts |
| Largest Contentful Paint (LCP) | 25% | High | Inline critical CSS, optimize hero image |
| Speed Index | 10% | High | Defer scripts + inline CSS |
| Cumulative Layout Shift (CLS) | 25% | Medium | Reserve space for dynamic elements |
| First Contentful Paint (FCP) | 10% | Medium | Remove render-blocking resources |
Notice the pattern? 55% of your score (TBT + LCP) is directly controlled by how JavaScript and CSS load. Apps are the biggest source of JavaScript on most Shopify stores. But you don't need to remove the apps — you just need to change when and how their code loads.
When a browser encounters a <script> tag without defer or async, it stops everything — stops parsing HTML, stops rendering pixels — until that script downloads and executes. A single 200KB review app script loading synchronously in theme.liquid can add 800ms to your TBT on a throttled mobile connection.
The solution isn't removing the review app. It's making that script load after the page renders. That's what script deferral does — and it's the single biggest lever for improving your Shopify speed score. For a deep dive on this, see our guide to fixing render-blocking resources on Shopify.
The One-Click Fix: Thunder Page Speed Optimizer
Before we dive into the manual strategies, here's the fastest path to 90+: let Thunder handle it automatically. Every strategy we cover below — script deferral, critical CSS, image optimization, font loading — Thunder does in one install.
What Thunder does automatically:
Defers All Render-Blocking Scripts
Every app script loads after paint — no manual code editing required
Inlines Critical CSS
Extracts above-the-fold styles and inlines them for instant rendering
Optimizes Image Loading
Lazy-loads offscreen images, prioritizes hero image for faster LCP
Fixes Font Loading
Preloads critical fonts and adds font-display: swap automatically
Average improvement: +27 points (with all apps installed)
That's 27 points without removing a single app. Most stores go from 40-60 to 70-90 on mobile, and from 60-80 to 90+ on desktop. Test your store's current score to see your starting point.
Free plan available · No credit card required · 30-second install · Works with all apps and themes
Strategy 1: Defer Render-Blocking Scripts
This is the single highest-impact optimization you can make. Render-blocking scripts account for 30-50% of most Shopify stores' speed score losses. Here's why they're so damaging and how to fix them.
The Problem
When an app installs on Shopify, it typically adds a <script src="..."> tag to your theme.liquid file. Without explicit defer or async attributes, browsers treat this as "stop everything and load this first." Multiply that by 10-15 apps, and you've got a traffic jam of scripts all trying to load before your page can even show its first pixel.
The Manual Fix
Before (render-blocking):
<script src="https://app-cdn.example.com/widget.js"></script> After (deferred):
<script src="https://app-cdn.example.com/widget.js" defer></script>
Open your theme code editor, navigate to theme.liquid, and add defer to every third-party script tag. For inline scripts (which can't use defer), wrap them in a DOMContentLoaded event listener or use setTimeout to delay execution by 2-3 seconds.
⚠️ Warning: Adding defer to the wrong script can break functionality. Payment scripts, Shopify's own analytics, and some app widgets expect synchronous loading. Test thoroughly on a duplicate theme before going live. This is one reason many merchants choose Thunder — it knows which scripts are safe to defer and handles the edge cases automatically.
Expected impact: 15-30 point improvement on mobile, 10-20 on desktop. This single change often gets stores from 50s to 70s-80s.
Strategy 2: Inline Critical CSS
CSS files are also render-blocking by default. Your browser won't paint a single pixel until all CSS in the <head> has downloaded and parsed. On most Shopify themes, that's 200-500KB of CSS — most of which styles elements below the fold or on other pages entirely.
The Manual Fix
- Extract critical CSS: Use a tool like Critical to identify which CSS rules are needed for above-the-fold content on your homepage.
- Inline it: Place those rules in a
<style>tag in your<head>. - Defer the rest: Load your full CSS file asynchronously using
<link rel="preload" href="style.css" as="style">with a fallback. - Repeat for each template: Product pages, collection pages, and your homepage each have different above-the-fold content. Each needs its own critical CSS.
This is technically complex and maintenance-heavy. Every theme update can change your CSS structure, requiring re-extraction. It's one of the most time-consuming manual optimizations — and one of the things Thunder automates completely. Check our features page to see how it works.
Expected impact: 5-15 point improvement, primarily on FCP and LCP.
Strategy 3: Optimize Images Properly
Images are the largest assets on most Shopify stores. A single unoptimized hero banner can weigh more than all your app scripts combined. The good news: image optimization is straightforward and high-impact.
Quick Wins
Hero image under 200KB: Your LCP element is usually the hero banner or first product image. Compress it to WebP format at 80% quality. Use Shopify's image_url filter with specific width: {{ image | image_url: width: 1200 }}
Explicit dimensions: Always include width and height attributes on <img> tags. This prevents CLS (layout shifts) as images load, which is worth 25% of your score.
Preload the hero: Add <link rel="preload" as="image" href="hero.webp"> in your <head> to tell the browser to start downloading your LCP image before it discovers it in the HTML.
Lazy-load everything else: Every image below the fold should have loading="lazy". Read our guide on lazy loading on Shopify for the full setup.
Expected impact: 5-20 points depending on your current image situation. Stores with uncompressed 2MB hero images will see dramatic improvements.
Strategy 4: Fix Font Loading
Fonts are sneaky speed killers. Each font weight is a separate file (40-100KB each). A typical Shopify store loads 4-8 font files, adding 200-600KB to the initial page load. Without font-display: swap, browsers show invisible text until fonts finish loading — wrecking your FCP score.
The Manual Fix
Limit font weights: Use at most 2 font families with 2 weights each (regular + bold). That's 4 files maximum.
Add font-display: swap: Ensure all @font-face declarations include font-display: swap so text renders immediately in a fallback font while custom fonts load.
Preload critical fonts: Add <link rel="preload" as="font" type="font/woff2" href="..." crossorigin> for the 1-2 fonts used in your above-the-fold content.
Self-host over Google Fonts: Downloading fonts and serving from Shopify's CDN eliminates a DNS lookup + connection to Google's servers.
Expected impact: 3-10 points, primarily on FCP and LCP.
Strategy 5: Lazy-Load Everything Below the Fold
Beyond images, you can lazy-load entire sections of your page. App widgets that appear in the footer, reviews sections below product descriptions, and Instagram feeds at the bottom — none of these need to load before the customer sees the page.
Advanced Lazy-Loading Techniques
Intersection Observer: Use the Intersection Observer API to detect when a section scrolls into view, then load its associated scripts. This works for review widgets, chat widgets, and social proof popups.
User interaction triggers: Some scripts only need to load when the user interacts. A chat widget can load on first mouse movement. An upsell popup can load when the user adds to cart. This "load on interaction" pattern keeps initial page weight minimal.
Skeleton screens: Show lightweight placeholder content while heavy sections load. This improves perceived performance and keeps CLS low because the layout doesn't shift when real content arrives.
Expected impact: 5-15 points on mobile. Varies based on how many below-fold scripts you can defer.
Strategy 6: Audit App Quality, Not Quantity
Instead of counting how many apps you have, audit how each app loads. Some apps are beautifully optimized — tiny scripts, deferred loading, minimal CSS. Others dump 500KB of unminified JavaScript synchronously into your theme. Knowing the difference is key.
How to Audit Each App's Speed Impact
- Open Chrome DevTools → Network tab on your store
- Disable each app one at a time (uninstall temporarily or use the app's disable toggle if available)
- Re-run PageSpeed Insights after each change (run 3 times, take the average)
- Log the score delta for each app — now you know exactly which apps cost the most points
- For high-cost apps, look for lighter alternatives that do the same thing with less code weight
We've seen cases where a single review app cost 20 points while a competitor's review app with the same features cost only 3 points. The functionality is identical — the code quality isn't. Check our third-party scripts guide for more on identifying heavy scripts.
Don't want to audit manually? Use the Thunder Shopify Analyzer to see exactly which scripts are loading on your store, how big they are, and which ones are render-blocking. It gives you an actionable report in seconds.
What Shopify Speed Score Should You Actually Target?
Let's be realistic. Here's what well-optimized Shopify stores with real apps actually score:
| Store Profile | Typical Desktop | Typical Mobile |
|---|---|---|
| Minimal store (3-5 apps, lightweight theme) | 95-100 | 85-95 |
| Standard store (10-15 apps, optimized) | 90-98 | 70-85 |
| Feature-rich store (15-25 apps, optimized) | 85-95 | 60-80 |
| Enterprise store (25+ apps, heavy features) | 75-90 | 50-70 |
A mobile score of 75-85 with 15 apps installed is excellent. It means your Core Web Vitals are passing and your store loads fast for real users. Don't chase a perfect 100 — that requires stripping away functionality that makes your store profitable.
What matters more than the lab score is your Core Web Vitals field data — the real performance experienced by actual visitors. Check this on PageSpeed Insights under "Discover what your real users are experiencing." If those metrics are green, your store is fast — regardless of what the lab score says.
For more context on what these numbers mean, read our deep dive on Shopify speed score vs Google PageSpeed and the relationship between speed and conversions.
Frequently Asked Questions
Can I really get a 90+ Shopify speed score without removing apps?
Yes — but it depends on which apps and how they load. The key isn't removing apps but optimizing how their scripts load. By deferring render-blocking JavaScript, inlining critical CSS, and lazy-loading non-essential resources, most stores can reach 90+ with 10-15 apps installed. Thunder Page Speed Optimizer automates this entire process.
How many apps is too many for Shopify speed?
There's no magic number. A store with 20 well-coded apps can outperform one with 5 poorly-coded apps. What matters is how each app loads its scripts. Apps that inject synchronous JavaScript into your theme.liquid or load large CSS files above the fold are the real speed killers. Use Chrome DevTools Network tab to identify which apps add the most weight.
Does Thunder work with all Shopify apps?
Thunder is compatible with all Shopify apps and themes. It works at the browser loading level — deferring scripts, inlining critical CSS, and optimizing resource loading order. This means it optimizes how any app's assets load without changing the app's functionality. In rare cases where an app requires synchronous loading (like payment widgets), Thunder detects this and leaves it alone.
What Shopify speed score should I aim for?
For most Shopify stores, a speed score between 70-90 on mobile represents excellent performance. Desktop scores above 90 are common. The real metric that matters is Core Web Vitals field data — if your LCP is under 2.5s, INP under 200ms, and CLS under 0.1 with real users, your store is performing well regardless of the lab score number.
Why is my mobile Shopify speed score so much lower than desktop?
Mobile scores simulate a mid-range phone on a slow 4G connection with heavy CPU throttling. Desktop simulates a fast computer on a cable connection. This throttling makes every unoptimized script cost 3-5x more on mobile. That's why script deferral and critical CSS inlining — which Thunder handles automatically — have a bigger impact on mobile scores.
Will optimizing my speed score actually increase sales?
Data consistently shows that faster stores convert better. Google's research found that a 1-second improvement in mobile load time can increase conversions by up to 27%. For Shopify specifically, stores with LCP under 2.5 seconds see 15-20% higher add-to-cart rates on average compared to stores loading in 4+ seconds. Speed isn't everything, but it removes friction from the buying process.
What's the best Shopify 90 mobile score optimization strategy in 2026?
The most effective strategy for hitting a 90+ mobile score in 2026 focuses on three areas: (1) Defer all non-critical JavaScript — this alone can gain 15-25 points on mobile because Lighthouse applies heavy CPU throttling. (2) Inline critical CSS and defer the rest — eliminates render-blocking stylesheets. (3) Optimize LCP by setting fetchpriority='high' on your hero image and preloading it. Thunder Page Speed Optimizer handles all three automatically, with an average 27+ point improvement on mobile specifically.