1. Why Shopify Speed Matters (The Revenue Impact)
Speed isn't a vanity metric. It's a revenue lever. Every second your Shopify store takes to load costs you real money — in lost conversions, higher bounce rates, and lower search rankings.
The data is unambiguous:
7%
conversion drop per second of additional load time
Source: Portent, 2023
53%
of mobile visitors leave if a page takes over 3 seconds
Source: Google/SOASTA
2x
higher conversion rate for sites loading in 2s vs 5s
Source: Akamai, 2024
The Google factor: Since the Page Experience update, Google uses Core Web Vitals as a ranking signal. Stores that pass all three vitals (LCP, CLS, INP) get a ranking boost over competitors that don't. For competitive e-commerce keywords, this edge can mean the difference between page 1 and page 2.
The compound effect: Speed improvements compound. A faster store gets better SEO rankings → more traffic → more conversions per visitor → higher revenue. A store doing $500K/year that improves load time by 1 second can reasonably expect $35K–50K in additional annual revenue from the conversion lift alone.
Bottom line: Shopify speed optimization isn't about chasing a number in a dashboard. It's about removing friction between your customer and the "Add to Cart" button. Every millisecond of delay is a customer reconsidering their purchase.
2. Understanding Your Speed Score
Your Shopify speed score appears in your admin under Online Store → Themes. It's a number from 0 to 100 powered by Google Lighthouse — the same engine behind PageSpeed Insights.
What Lighthouse Actually Measures
Your score is a weighted average of five performance metrics. Understanding the weights tells you where to focus:
Total Blocking Time (TBT)
Time the main thread is blocked by JavaScript. The heaviest weight — fixing this has the biggest impact.
Largest Contentful Paint (LCP)
Time until the biggest visible element renders. Usually the hero image or main heading.
Cumulative Layout Shift (CLS)
How much elements jump around during load. Caused by images without dimensions or late-loading fonts.
First Contentful Paint (FCP)
Time until the browser renders anything at all. Blocked by render-blocking CSS and JS.
Speed Index (SI)
How quickly visible content fills the viewport. A holistic visual loading measure.
Shopify's Scoring: What You're Up Against
Shopify runs Lighthouse on your homepage only, using a simulated mobile device with throttled CPU (4x slowdown) and a mid-tier 4G connection. This is intentionally harsh — it simulates the experience of a user on a budget Android phone with spotty cell service.
Here's what makes Shopify scoring particularly challenging:
- → Shopify injects its own scripts (analytics, checkout, dynamic checkout buttons) that consume 15–25 points of your budget before your theme even loads
- → Third-party apps inject scripts you can't easily defer or control
- → The test runs on your homepage, which is often the heaviest page (hero images, featured collections, promotional banners)
- → Scores naturally fluctuate 5–15 points between runs due to test infrastructure variance
Key insight: The average Shopify store scores 25–55. If you're in this range, you're normal — not broken. The goal isn't 100 (practically impossible with apps and analytics). The goal is getting fast enough that speed isn't costing you sales — typically 60+ on mobile.
3. The #1 Fastest Fix: Thunder Page Speed Optimizer
Before we dive into 12 manual optimization techniques (each requiring time, skill, and risk), let's talk about the approach that handles most of them automatically in under a minute.
Thunder Page Speed Optimizer is a Shopify app that optimizes your store's loading performance at the network level — without modifying your theme files. It handles the hardest, highest-impact optimizations that would take a developer days or weeks to implement manually.
What Thunder Optimizes Automatically
Script Deferral & Sequencing
Defers all render-blocking JavaScript — including third-party app scripts — while maintaining correct execution order and dependencies
Critical CSS Extraction & Inlining
Automatically generates above-the-fold CSS for each page template and inlines it for instant first paint
Image Lazy Loading & Preloading
Lazy-loads offscreen images and intelligently preloads the LCP image for faster rendering
Font Optimization
Preloads critical fonts, applies font-display: swap, and eliminates flash of invisible text (FOIT)
Resource Hints (Preconnect & Prefetch)
Establishes early connections to critical third-party domains for faster resource loading
Daily Speed Monitoring
Tracks your PageSpeed score daily — know your true average instead of relying on noisy single tests
How to Get Started (30 Seconds)
Install Thunder from the Shopify App Store — free plan available, no credit card required
Enable optimizations with one click in the Thunder dashboard — all features activate instantly
Test your score on PageSpeed Insights — most stores see an immediate 27+ point improvement
Average improvement: +27 PageSpeed points
Stores typically jump from red (25–45) to orange/green (55–80+) within minutes. Stores with more apps and heavier themes see the biggest gains — we've seen improvements of 40+ points on app-heavy stores.
Zero Risk — Here's Why
- • No theme modifications: Thunder works at the network level, not in your theme code
- • Instant rollback: Disable or uninstall anytime — your store reverts to its original state
- • No leftover code: Unlike manual changes, nothing is left behind if you uninstall
- • Free plan: Test the impact before committing to a paid plan
Free plan available · No credit card required · 30-second install · Works with all themes
4. Manual Optimization Methods (12 Techniques)
Whether you're complementing Thunder or going the DIY route, these are the 12 most impactful Shopify speed optimization techniques. Each includes a difficulty rating, time estimate, and which metrics it improves.
4.1 Image Optimization
Easy ⏱ 1–2 hoursImages are typically the heaviest assets on any Shopify store, and image optimization often delivers the most visible improvement. The good news: it's one of the easiest wins.
What to do:
- • Use WebP format for all images (Shopify CDN supports automatic conversion via URL parameters)
- • Compress images to 80% quality — the visual difference is imperceptible but file sizes shrink 50–70%
- • Set explicit
widthandheightattributes on all<img>tags to prevent CLS - • Use responsive
srcsetto serve appropriately sized images for each device - • Avoid hero images wider than 1600px — anything larger is wasted bandwidth
- • Use Shopify's
image_urlfilter with width parameters:{{ image | image_url: width: 800 }}
Metrics improved: LCP, Speed Index · Thunder equivalent: Automatic LCP image preloading + lazy loading
4.2 App Audit & Cleanup
Easy ⏱ 2–4 hoursThe average Shopify store has 6–8 apps installed, and each one can inject JavaScript and CSS into every page load. Some apps add 200–500ms of load time each. An app audit is often the highest-ROI activity for Shopify speed optimization.
What to do:
- • List every installed app and categorize: essential, nice-to-have, unused
- • Uninstall anything in the "unused" category immediately
- • For "nice-to-have" apps, check if the feature can be achieved with native Shopify functionality
- • After uninstalling, search your theme files for leftover script tags and snippets — uninstalling doesn't always clean up
- • Use browser DevTools (Network tab) to identify which apps inject the heaviest scripts
- • Consider consolidating: one multi-feature app is faster than three single-feature apps
Metrics improved: TBT, FCP, LCP · Thunder equivalent: Defers app scripts without requiring removal
4.3 Theme Optimization
Medium ⏱ 1–3 daysYour theme is the foundation of your store's performance. Some themes ship with 400KB+ of CSS and JavaScript before any apps are added. Switching to a well-optimized theme can move your baseline score by 15–25 points.
What to do:
- • Consider Shopify's Dawn-based themes (Dawn, Refresh, Craft, Sense) — they're the fastest out of the box
- • Remove unused theme features and sections you're not displaying
- • Reduce homepage sections — each section adds Liquid processing time and DOM elements
- • Minimize the number of featured products/collections shown on the homepage
- • If staying with your current theme, remove unused CSS classes and JavaScript functions
Metrics improved: All metrics · Thunder equivalent: Works with any theme; optimizes delivery regardless of theme quality
4.4 Script Deferral
Advanced ⏱ 4–8 hours Render-blocking JavaScript is the #1 speed killer on most Shopify stores. Every script in the <head> without defer or async blocks the browser from rendering anything until it's downloaded and executed.
What to do:
- • Add
deferto all non-critical script tags in your theme - • Move scripts from
<head>to before</body>where possible - • Use
asyncfor independent scripts (analytics, tracking pixels) - • Warning: Third-party app scripts are the biggest offenders, but you can't edit them directly — modifying app scripts often breaks functionality
- • Test thoroughly after any script changes — deferred scripts may execute in a different order
Metrics improved: TBT, FCP, LCP · Thunder equivalent: ✅ Handles this automatically, including app scripts, with dependency mapping to prevent breakage
4.5 Critical CSS Inlining
Advanced ⏱ 3–5 days
CSS files in the <head> are render-blocking — the browser won't paint anything until all CSS is downloaded and parsed. Critical CSS extracts only the styles needed for above-the-fold content and inlines them, allowing the browser to paint immediately while loading the rest asynchronously.
What to do:
- • Use tools like Critical (npm package) to extract above-the-fold CSS
- • Inline the critical CSS in a
<style>tag in the<head> - • Load the full stylesheet asynchronously using
rel="preload"with an onload handler - • Challenge: You need different critical CSS for each page template (homepage, product, collection, etc.)
- • Critical CSS must be regenerated whenever you change your theme or layout
- • Getting it wrong causes a flash of unstyled content (FOUC) — worse than no optimization at all
Metrics improved: FCP, LCP, Speed Index · Thunder equivalent: ✅ Auto-generates and maintains critical CSS per page template
4.6 Font Optimization
Medium ⏱ 2–4 hoursCustom web fonts are a silent performance killer. Each font weight/style is a separate file (typically 20–50KB each), and browsers often hide text until fonts load — the dreaded Flash of Invisible Text (FOIT).
What to do:
- • Use
font-display: swapon all @font-face declarations — shows fallback text immediately - • Preload your primary font:
<link rel="preload" href="font.woff2" as="font" crossorigin> - • Limit to 2 font weights maximum (regular + bold) — each extra weight adds a separate download
- • Self-host fonts instead of loading from Google Fonts (saves a DNS lookup + connection)
- • Use WOFF2 format — it has the best compression and widest browser support
- • Consider system font stacks for body text — they load instantly and look great
Metrics improved: FCP, CLS, LCP · Thunder equivalent: ✅ Automatic font preloading and font-display: swap
4.7 Lazy Loading
Easy ⏱ 1–2 hoursLazy loading defers the download of offscreen images and videos until the user scrolls near them. This means the browser only loads what's visible, dramatically reducing initial page weight.
What to do:
- • Add
loading="lazy"to all images below the fold - • Don't lazy-load your hero image or LCP element — that makes LCP worse
- • Use Shopify's
image_tagLiquid filter which includes lazy loading by default - • Lazy-load embedded videos (YouTube, Vimeo) — use facade patterns that load a thumbnail first
- • Consider lazy-loading non-critical iframes (chat widgets, social feeds)
Metrics improved: Speed Index, LCP (indirectly by reducing contention) · Thunder equivalent: ✅ Automatic lazy loading with LCP awareness
4.8 Preloading & Prefetching
Medium ⏱ 1–2 hoursResource hints tell the browser to start loading critical assets before it naturally discovers them. The right hints can shave hundreds of milliseconds off your load time.
What to do:
- •
preloadyour hero/LCP image so the browser fetches it immediately - •
preconnectto critical third-party domains (CDN, analytics, font servers) - •
dns-prefetchfor less critical third-party domains - •
prefetchresources for likely next pages (product page from collection) - • Don't over-preload — each preload hint competes for bandwidth; limit to 2–3 critical resources
Metrics improved: LCP, FCP · Thunder equivalent: ✅ Automatic preconnect and intelligent LCP preloading
4.9 Third-Party Script Management
Medium ⏱ 2–4 hoursThird-party scripts — Facebook Pixel, Google Analytics, chat widgets, review apps, pop-up tools — are often the biggest performance drain. A single chat widget can add 300KB+ of JavaScript and 500ms+ of blocking time.
What to do:
- • Audit all third-party scripts using Chrome DevTools → Network tab → filter by "3rd-party"
- • Load chat widgets on user interaction (click a button to load) rather than on page load
- • Use Google Tag Manager to control script loading timing
- • Delay non-essential tracking scripts until after page interaction
- • Replace heavy social sharing buttons with simple share links
- • Use Shopify's Customer Privacy API for consent-based script loading
Metrics improved: TBT, FCP, LCP · Thunder equivalent: ✅ Defers all third-party scripts automatically while maintaining functionality
4.10 Code Minification
Easy ⏱ 1–2 hoursMinification removes whitespace, comments, and shortens variable names in CSS and JavaScript files. It typically reduces file sizes by 15–30%. While it's a smaller win than script deferral or critical CSS, it's easy and has no downside.
What to do:
- • Most modern Shopify themes ship minified CSS and JS — check if yours does
- • For custom code, use tools like Terser (JS) and cssnano (CSS)
- • Shopify automatically serves assets with gzip compression, so minification stacks on top
- • Remove unused CSS with tools like PurgeCSS — this often has a bigger impact than minification alone
- • Don't minify in development — use build tools that minify for production only
Metrics improved: FCP, Speed Index · Impact: Small but additive
4.11 Reduce DOM Size
Medium ⏱ 2–6 hoursA large DOM (Document Object Model) slows down everything: style calculations, layout, paint, and JavaScript operations. Lighthouse flags pages with more than 1,500 DOM elements. Many Shopify homepages exceed 3,000–5,000 elements due to feature-rich themes and multiple sections.
What to do:
- • Reduce the number of products shown in homepage collections (8–12 is usually enough)
- • Remove unused theme sections and blocks
- • Flatten deeply nested HTML structures — aim for max 15 levels of nesting
- • Use pagination instead of "load all" for collection pages
- • Avoid rendering hidden elements — use Liquid conditionals instead of CSS
display: none - • Remove unnecessary wrapper divs (common in page builder themes)
Metrics improved: TBT, all metrics indirectly · Impact: Medium — more noticeable on lower-end devices
4.12 Server-Side Rendering Considerations
Limited Control ⏱ VariesShopify handles server-side rendering through its Liquid template engine, so you don't control the server infrastructure. However, the complexity of your Liquid code directly affects server response time (TTFB), which cascades into every other metric.
What to do:
- • Simplify complex Liquid loops — avoid nested
forloops withinforloops - • Reduce the number of Liquid objects accessed on each page
- • Use Shopify's section rendering API for dynamic content updates instead of full page reloads
- • Keep collection pages to reasonable product counts (under 50 per page)
- • Minimize use of
{% include %}— each include adds processing overhead (use{% render %}instead) - • For headless stores: Hydrogen/Oxygen gives you full SSR control but is a complete rebuild
Metrics improved: FCP, LCP (via reduced TTFB) · Impact: Medium for complex stores
Don't want to do all 12? Thunder handles techniques #1, #4, #5, #6, #7, #8, and #9 automatically — that's the 7 highest-impact optimizations without touching a line of code. Combine with a manual app audit (#2) and theme choice (#3) for optimal results.
5. Advanced Techniques (For Developers)
If you have development resources and want to push performance further, these advanced techniques can squeeze out additional improvements.
Predictive Prefetching
Use the Intersection Observer API to prefetch product pages as users scroll through collections. When a product card enters the viewport, start loading its page in the background. By the time the user clicks, the page is already cached.
// Prefetch on hover (simple version)
document.querySelectorAll('a[href*="/products/"]').forEach(link => {
link.addEventListener('mouseenter', () => {
const prefetch = document.createElement('link');
prefetch.rel = 'prefetch';
prefetch.href = link.href;
document.head.appendChild(prefetch);
}, {once: true});
});Service Worker Caching
Register a service worker to cache static assets (CSS, JS, fonts, images) on first visit. Subsequent page loads will be near-instant for cached resources. Be careful with cache invalidation — stale CSS/JS can break functionality.
Note: Shopify limits service worker scope. You can register one for your storefront domain but not for checkout.
Facade Pattern for Heavy Embeds
Replace heavy third-party embeds (YouTube videos, Instagram feeds, Google Maps) with lightweight static placeholders that load the real embed only when the user interacts. A YouTube facade saves ~500KB of JavaScript on initial load.
Web Workers for Heavy Computation
Move expensive JavaScript operations (filtering, sorting, search) to Web Workers so they don't block the main thread. This directly improves TBT and INP. Particularly useful for collection pages with complex filtering.
Optimized Liquid for LCP
Ensure your LCP image is rendered in the initial HTML response (not loaded via JavaScript). Use Shopify's image_tag with preload: true for hero images. Avoid wrapping the LCP element in JavaScript-dependent components.
6. Core Web Vitals Deep Dive for Shopify
Core Web Vitals are the three metrics Google uses for ranking. Understanding each one — and their specific challenges on Shopify — is essential for effective speed optimization.
Largest Contentful Paint
What it measures: Time until the largest visible element (hero image, heading, or video poster) renders. Target: Under 2.5 seconds.
Why Shopify stores struggle: Large hero images, render-blocking CSS that delays painting, slow server response times on complex Liquid templates, and third-party scripts competing for bandwidth.
How to fix LCP on Shopify:
- • Preload your hero image with
<link rel="preload"> - • Compress and resize hero images (max 1200px wide for mobile, 1600px for desktop)
- • Inline critical CSS to unblock rendering
- • Defer all render-blocking JavaScript
- • Use responsive images with
srcsetfor device-appropriate sizing - • Or install Thunder — it addresses all of the above automatically
Cumulative Layout Shift
What it measures: Visual stability — how much elements move around as the page loads. Target: Under 0.1.
Why Shopify stores struggle: Images without explicit dimensions, dynamically injected app content (pop-ups, banners, review widgets), web fonts causing text reflow, and slideshow/carousel animations.
How to fix CLS on Shopify:
- • Set explicit
widthandheighton all images - • Reserve space for dynamically loaded content (ads, reviews, pop-ups)
- • Use
font-display: swapwith size-adjusted fallback fonts - • Avoid inserting content above existing content after page load
- • Set fixed dimensions on slideshow/carousel containers
- • Use CSS
aspect-ratiofor media containers
Interaction to Next Paint
What it measures: Responsiveness — the delay between a user interaction (click, tap, keypress) and the next visual update. Target: Under 200ms. INP replaced FID (First Input Delay) in March 2024.
Why Shopify stores struggle: Heavy JavaScript execution on the main thread (especially from apps and analytics), complex DOM operations on interaction (filtering, cart updates), and large DOM sizes that make re-rendering expensive.
How to fix INP on Shopify:
- • Reduce JavaScript execution time by deferring non-critical scripts
- • Break up long tasks (>50ms) into smaller chunks using
requestIdleCallback - • Reduce DOM size to speed up re-rendering after interactions
- • Use
content-visibility: autofor offscreen content - • Debounce event handlers on scroll, resize, and input events
- • Minimize the number of installed apps to reduce main thread contention
7. Speed Monitoring & Maintenance
Speed optimization isn't a one-time project — it's ongoing maintenance. Every new app, theme update, or content change can impact performance. Without monitoring, you won't know when things regress.
Set Up Continuous Monitoring
Daily Lab Testing
Run automated Lighthouse tests daily and track the trend over time. A rolling 7-day average eliminates test noise and shows your true baseline. Thunder includes daily monitoring in all plans — you'll see your score tracked automatically in the dashboard.
Field Data (CrUX)
Check your Chrome User Experience Report (CrUX) data monthly via PageSpeed Insights. This shows real-user performance across 28 days. If CrUX shows all green, your SEO is unaffected regardless of lab score fluctuations.
Google Search Console
The Core Web Vitals report in Search Console shows which pages pass or fail for your actual visitors. It groups URLs by status and identifies specific issues. Check monthly.
Speed Maintenance Checklist
Before installing a new app: Test your speed score, install the app, test again. If it drops more than 5 points, consider if the functionality is worth the trade-off.
Monthly app audit: Review installed apps. Disable or remove any you're not actively using.
After theme updates: Re-test speed. Theme updates can introduce new scripts or change loading behavior.
Image audits: Quarterly check that new images follow your compression and sizing guidelines.
Third-party script review: Check if marketing scripts (pixels, chat, pop-ups) are still needed and configured optimally.
Pro tip: Set a calendar reminder to check your speed score on the 1st of each month. If your score has dropped more than 10 points since last month, investigate what changed — it's almost always a new app or theme update.
8. Case Studies: Real Shopify Speed Optimization Results
Theory is useful, but results matter. Here are three real Shopify stores that dramatically improved their performance with Thunder Page Speed Optimizer.
SafeRacks
Home & Garage StorageSafeRacks sells premium overhead garage storage solutions. With a content-heavy homepage featuring large product images, comparison tables, and multiple app integrations, their mobile PageSpeed score was stuck in the red zone.
Before Thunder
28
After Thunder
71
Improvement
+43
Key improvements: LCP dropped from 8.2s to 3.1s, TBT reduced by 65%, CLS improved to 0.05
Ickle Bubba
Baby & NurseryIckle Bubba is a popular UK baby brand with a feature-rich Shopify store including product configurators, review systems, and multiple marketing integrations. Their mobile score reflected the weight of these necessary tools.
Before Thunder
32
After Thunder
68
Improvement
+36
Key improvements: Render-blocking resources eliminated, font loading optimized, critical CSS auto-generated for all templates
Cult Pens
Specialty RetailCult Pens is a well-known UK specialty retailer with a massive product catalog and complex collection pages. With thousands of products and extensive filtering, performance was a significant challenge.
Before Thunder
22
After Thunder
56
Improvement
+34
Key improvements: TBT reduced from 4,200ms to 1,100ms, LCP improved by 3.5s, all without removing a single app
Common pattern: All three stores kept their existing apps and theme — Thunder optimized how resources were delivered, not what was installed. The stores with more apps (and thus more render-blocking scripts) saw the largest improvements. See what Thunder can do for your store →
Frequently Asked Questions
How do I speed up my Shopify store?
The fastest way is to install Thunder Page Speed Optimizer, which automatically defers render-blocking scripts, inlines critical CSS, optimizes images, and preloads fonts — typically adding 27+ PageSpeed points in minutes. For manual optimization, focus on image compression (WebP format), removing unused apps, deferring JavaScript, inlining critical CSS, optimizing fonts, and choosing a lightweight theme like Dawn. Start with the highest-impact changes: script deferral and image optimization usually deliver the biggest improvements.
What is a good Shopify speed score?
Google Lighthouse rates 90–100 as good (green), 50–89 as needs improvement (orange), and 0–49 as poor (red). Most Shopify stores score between 25 and 55 due to third-party apps and heavy themes. A realistic target for most merchants is 60–80 after optimization. Thunder users typically see scores in the 65–90+ range. Remember: the exact number matters less than whether your Core Web Vitals pass in the field.
Does Shopify speed affect SEO rankings?
Yes. Google uses Core Web Vitals (LCP, CLS, INP) as a ranking signal in its page experience update. While speed alone won't outrank great content, two pages with similar content and authority will see the faster one ranked higher. Studies show that a 1-second improvement in load time can increase organic traffic by 5–10%. Beyond SEO, speed directly impacts bounce rate and conversion rate — every second of delay costs roughly 7% in conversions.
Why is my Shopify store so slow?
The most common causes are: too many installed apps (each injecting JavaScript and CSS), unoptimized images (large files without compression or lazy loading), heavy third-party themes with bloated code, render-blocking scripts in the <head>, excessive custom fonts, and third-party tracking scripts (Facebook Pixel, Google Analytics, chat widgets). Shopify's own platform scripts also consume a portion of your performance budget before your theme even loads.
Does removing Shopify apps improve speed?
Yes, but with an important caveat: uninstalling an app from the Shopify admin doesn't always remove its code from your theme. Many apps leave behind script tags, CSS files, and Liquid snippets that continue to slow your store. After uninstalling, manually check your theme.liquid file and snippets folder for leftover code. Alternatively, Thunder optimizes how app scripts load without requiring you to remove the apps themselves.
What are Core Web Vitals and why do they matter for Shopify?
Core Web Vitals are three metrics Google uses to measure real-user experience: LCP (Largest Contentful Paint) measures loading speed, CLS (Cumulative Layout Shift) measures visual stability, and INP (Interaction to Next Paint) measures responsiveness. Google uses these as ranking signals. For Shopify stores, LCP is typically the hardest to pass due to large hero images and render-blocking resources. Thunder specifically targets all three Core Web Vitals with automated optimizations.
Is Thunder Page Speed Optimizer safe to use?
Yes. Thunder doesn't modify your theme files — it works at the network level to optimize how resources are delivered to browsers. If you ever uninstall Thunder, your store reverts to its original state with zero leftover code. Thunder is used by thousands of Shopify stores including enterprise brands. It includes a free plan so you can test the impact before committing, and paid plans include a 7-day free trial.
How long does Shopify speed optimization take?
With Thunder, you'll see results in minutes — install the app, enable optimizations, and your next PageSpeed test will show the improvement. Manual optimization varies: image compression takes 1–2 hours, app cleanup takes 2–4 hours, theme optimization takes 1–2 days, and critical CSS implementation can take a full week for a developer. A comprehensive manual optimization project typically takes 2–4 weeks. Most merchants start with Thunder for immediate gains and then tackle manual improvements over time.
What's the difference between lab data and field data for Shopify speed?
Lab data (your Lighthouse/PageSpeed score) comes from a simulated test on a controlled device with throttled CPU and network. Field data (Core Web Vitals from the Chrome User Experience Report) comes from real visitors using your store over 28 days. Google uses field data for SEO rankings, not lab data. Your lab score can fluctuate 10–15 points between runs due to test variability, while field data is much more stable. Both matter, but field data is what ultimately affects your search rankings.
Can I get a 100 PageSpeed score on Shopify?
It's theoretically possible but practically unrealistic for a real store with apps, analytics, and marketing tools. Shopify's own platform scripts consume 15–25 points of your budget before your theme loads. A score of 100 typically requires zero third-party scripts, minimal images, and a stripped-down theme — which isn't practical for a functioning e-commerce store. Aim for 70–90 instead, which is achievable with proper optimization and delivers excellent real-world performance.