Why does JavaScript hurt Shopify Lighthouse scores so much?

JavaScript is the largest contributor to slow Shopify performance because every JS file must be downloaded, parsed, and executed before the browser can continue rendering the page. During that execution the main thread is blocked — unable to respond to user interactions (causing poor INP) or finish rendering (causing poor LCP). The average Shopify store with 15–20 apps installed can add 1,500–4,000 ms of JavaScript execution time, dropping a clean theme score of 70 into the 20–35 range. Apps are the single biggest source of JS bloat because they inject scripts on every page, even pages where the app is not relevant.

How do I find leftover app script tags in my Shopify theme?

In your Shopify admin, go to Online Store > Themes > Actions > Edit code. Open theme.liquid and search for <script tags, then cross-reference each script src URL against your currently installed apps. Also check the /snippets folder for files named after apps (e.g., klaviyo-snippet.liquid, gorgias-widget.liquid). Any script tag pointing to a domain belonging to an app you have uninstalled is an orphan — delete the entire render or include call for that snippet. This audit alone often improves mobile Lighthouse by 10–20 points.

Should I use defer or async on Shopify script tags?

Use defer for the majority of non-critical scripts — analytics, tracking pixels, review widgets, social share buttons, and chat widgets. Defer downloads the script in parallel with HTML parsing but executes it only after the DOM is complete, preserving execution order. Use async only for fully independent scripts that have no dependencies and do not need to run in a specific order relative to other scripts. Never add defer or async to scripts that initialize critical above-the-fold functionality or that other scripts depend on without thorough testing, as this can break checkout or add-to-cart behaviour.

What Shopify themes are fastest for Lighthouse scores?

Dawn is Shopify's official reference theme for Online Store 2.0 and is built with an HTML-first, JavaScript-only-as-needed philosophy — scoring 65–80 on mobile Lighthouse on a clean install with no apps. Other fast options from the official Theme Store include Craft, Sense, and Crave. Avoid themes that ship with multiple JavaScript libraries (jQuery, animation frameworks, multiple UI kits), auto-playing video sections, or built-in third-party feature integrations that load external scripts. Any theme with a mobile PageSpeed score below 50 on the demo store (before apps) is a red flag.

How much does JavaScript from apps actually hurt performance?

Each installed Shopify app adds between 50 and 200 ms of JavaScript overhead per page load, according to Easy Apps eCom data from 2026. A store with 15 apps can add 750–3,000 ms of execution time on top of the base theme. Real-world examples show stores with active marketing stacks (Facebook pixel, Google Tag Manager, Klaviyo, Attribuly, Tidio, Adobe TypeKit, Amazon Ads, Microsoft Clarity all loading simultaneously) reaching 4.5 seconds of JavaScript execution time alone — a level no theme can overcome. Removing just 3–4 unused trackers typically produces a measurable score improvement within the same audit session.

Ira Bodnar·July 17, 2026·14 min read

Reducing Shopify theme JavaScript for better Lighthouse scores: a complete 2026 playbook.

The average Shopify store scores 30–55 on mobile Lighthouse — mostly because of JavaScript bloat. We tested every major approach to reducing Shopify theme JavaScript for better Lighthouse scores on live stores and ranked them by actual mobile score improvement.

Built by our community of 2,000 marketers

Free skills and prompts for paid ads and SEO

Templates for Claude, ChatGPT and Perplexity.

Clients we work withClients we
work with

JavaScript is the single largest driver of slow Shopify stores in 2026 — and it is almost entirely within your control to fix.

A typical Shopify store with 15–20 apps installed drops from a baseline score of 70 on a clean theme to the low 20s on mobile Lighthouse. Every extra second of load time costs you real revenue — research shows a 1-second improvement in page load translates to roughly a 7% improvement in conversions for ecommerce stores.

Reducing Shopify theme JavaScript for better Lighthouse scores is not optional if you want to compete organically in 2026. Here is what the data shows:

Each installed Shopify app adds between 50 and 200 ms of JavaScript overhead to every page load (Easy Apps eCom, 2026) — a store with 10 apps can accumulate over 1.5 seconds of JS execution time before a single pixel renders.
Shopify’s own performance best practices require JavaScript bundles to stay under 16 KB each; most theme-plus-app stacks ship 400–900 KB of uncompressed JS on the homepage alone.
Stores that move from a Lighthouse mobile score of 35 to 75 regularly see 2–3 second improvements in LCP and, per conservative benchmarks, a $7,000–$70,000/year revenue uplift depending on store size.

How we tested

Over ten weeks we applied each JavaScript reduction approach to live Shopify stores generating between $80K and $1.8M per month across fashion, beauty, home goods, and supplements. We ran Lighthouse audits in incognito mode via Chrome DevTools before and after each intervention, using the median of five runs to account for variance. Where an approach required developer work, we used a mid-level Shopify developer; where it could be automated, we let the tool handle it.

We scored five dimensions equally:

Mobile Lighthouse score improvement — the raw before/after delta on the Performance score
Time-to-implement — hours of developer or operator effort required
Risk of breaking functionality — how likely the change is to break cart, checkout, or app features
Durability — does the fix hold after future theme updates or app installs?
Measurable business impact — conversion rate and organic traffic movement in the 60 days post-fix

No vendor paid for placement. Ryze is our own product, and we have flagged that wherever it appears so you can weigh it accordingly.

All 10 approaches, at a glance

Rank	Approach	Best for	Effort	Score lift
01	Ryze AI autonomous audit Winner	Find + fix JS bloat automatically	Zero-touch	+31 pts avg
02	App audit & removal	Cutting unused app JS overhead	Low	+8–20 pts
03	Switch to Dawn / OS 2.0 theme	Replacing JS-heavy legacy themes	Medium	+10–25 pts
04	defer / async on non-critical scripts	Eliminating render-blocking JS	Low–Med	+6–15 pts
05	Google Tag Manager consolidation	Taming third-party tracker pile-up	Medium	+5–12 pts
06	JS minification & bundle splitting	Reducing parse and execute time	Medium	+4–10 pts
07	Lazy-load below-fold JS modules	Deferring section-specific scripts	Medium	+5–9 pts
08	Remove unused theme sections & code	Eliminating shipped-but-hidden JS	Low	+3–8 pts
09	LCP image preload + fetchpriority	Unblocking hero render from JS queue	Low	+4–7 pts
10	Lighthouse CI in deployment pipeline	Preventing future regressions	Med–High	Maintains score

Get a free instant audit

Get a free, instant read on your paid ads or SEO — and fix it right away.

Paid ads audit

Catch wasted spend & broad-match leaks
Find account structure gaps
Rank your quickest wins
Spot PMax & brand-search overlap
Check conversion-tracking health
Benchmark CPC vs your industry
Catch wasted spend & broad-match leaks
Find account structure gaps
Rank your quickest wins
Spot PMax & brand-search overlap
Check conversion-tracking health
Benchmark CPC vs your industry

Free · no credit card · instant

SEO audit

Find keyword & ranking gaps
Catch technical SEO issues
Rank your fastest wins
Surface thin & duplicate pages
Check indexing & crawl coverage
Compare backlinks vs competitors
Find keyword & ranking gaps
Catch technical SEO issues
Rank your fastest wins
Surface thin & duplicate pages
Check indexing & crawl coverage
Compare backlinks vs competitors

Free · no credit card · instant

The full playbook

Approaches #2–#10, tested and ranked

02Biggest quick win for most stores

App audit and removal

The average Shopify store installs 15 to 20 apps, and each one can add between 50 and 200 ms of JavaScript overhead to every page load. That arithmetic compounds fast: a store with 12 apps loading an average of 100 ms each is adding 1.2 seconds of JavaScript execution before a single product image appears. Scandiweb’s 2026 Shopify performance report found render-blocking app scripts are the leading cause of poor Core Web Vitals across the stores they audit.

The audit process is straightforward: open Chrome DevTools, go to the Network tab, filter by JS, and identify which domains are loading scripts on every page. Cross-reference against your installed apps list. Apps you stopped actively using six months ago are almost always still injecting scripts. Removing three to four unused trackers — say, an old chat widget, an abandoned loyalty app, and a defunct review importer — routinely improves mobile Lighthouse scores by 8 to 20 points in a single afternoon. Check theme.liquid for leftover script tags from apps you already uninstalled; Shopify does not always clean these up automatically.

PricingFree (manual) or $29–$99/mo via automated audit tools

ProsImmediate score gains with zero code changes; removes the root cause not just symptoms

ConsRequires honest evaluation of which apps are earning their weight; some app features need replacing

VerdictThe single highest-ROI starting point for reducing Shopify theme JavaScript — tackle this before anything else

03Best structural fix for JS-heavy legacy themes

Switch to Dawn or another OS 2.0 theme

Shopify’s Dawn theme is built around a deliberate philosophy: HTML and CSS handle everything they can, and JavaScript is used only as a progressive enhancement where no native browser solution exists. On a clean install with no apps, Dawn typically scores 65–80 on mobile Lighthouse — a baseline that most legacy themes, pre-loaded with sliders, parallax libraries, and multiple UI frameworks, cannot come close to. If your current theme ships with jQuery, a dedicated animation library like GSAP loaded globally, and a built-in carousel, you are carrying dead weight on every single page.

When evaluating themes in the Shopify Theme Store, Shopify itself sets a minimum Lighthouse score of 60 for listing approval. Look for themes that avoid multiple JavaScript libraries, do not auto-load video or parallax on mobile, and do not bundle third-party features (chat, reviews, loyalty) into the theme core. Stores migrating from a jQuery-dependent theme to Dawn have seen mobile Lighthouse scores jump by 10 to 25 points on the homepage alone, before any further optimization. Pair the migration with an SEO audit to make sure canonical tags, structured data, and internal links survived the switch intact.

PricingFree (Dawn, Craft, Sense, Crave from Shopify Theme Store)

ProsHTML-first architecture; Dawn scores 65–80 on mobile Lighthouse on a clean install; no jQuery dependency

ConsMigration effort for heavily customized themes; potential design rebuild; one-time disruption

VerdictThe most durable long-term fix for stores stuck on legacy themes loaded with jQuery and animation libraries

Why this matters

Most approaches here require manual effort that decays over time as new apps get installed and theme updates ship new scripts. Ryze AI is the only option in this guide that continuously monitors your Shopify JavaScript footprint, flags regressions automatically, and implements fixes 24/7. Learn more at get-ryze.ai.

04Best code-level fix for render-blocking JavaScript

defer and async on non-critical script tags

Parser-blocking scripts are scripts that force the browser to stop constructing the DOM until the script has been fully downloaded, parsed, and executed. They are one of the most common Lighthouse flags on Shopify stores, and they directly damage First Contentful Paint and Largest Contentful Paint scores. The fix is adding defer or async attributes to non-critical script tags in your theme files. defer executes the script after HTML parsing completes but before DOMContentLoaded; async executes immediately once downloaded, regardless of parsing state.

Shopify’s official performance documentation explicitly recommends using defer or async on all script tags that are not required for above-the-fold rendering. The practical target: anything that is not the cart, variant selector, or payment processing logic should be deferred. Analytics tags, review widgets, wishlist scripts, upsell pop-up initializers — all of these can safely load after the page is interactive. Stores applying this across their theme.liquid and section files have recorded 6 to 15 point mobile Lighthouse improvements, with LCP reductions of 400–900 ms on 3G simulations. See also our guide on Shopify Core Web Vitals for a deeper dive into LCP and INP optimization.

PricingFree (developer time: 1–4 hours depending on theme complexity)

ProsDirectly eliminates parser-blocking behaviour; measurable FCP and LCP improvement; safe when applied correctly

ConsSome scripts break if deferred (order-dependent code); requires testing each tag individually

VerdictA mandatory fix for any store where Lighthouse flags render-blocking resources — high impact, low cost

05Best for taming third-party tracker JavaScript pile-up

Google Tag Manager consolidation

One store in our test cohort was loading Facebook Pixel, TikTok Pixel, Klaviyo, Google Analytics 4, Microsoft Clarity, Amazon Ads attribution, a ShareASale tag, and a custom retargeting script — all synchronously in theme.liquid. JavaScript execution time on that homepage alone was 4.5 seconds. Consolidating all of these into Google Tag Manager, setting non-essential tags to fire only after the window load event, and removing three tags that had not been actively used in six months cut execution time to under 1.8 seconds and moved the mobile Lighthouse score from 24 to 38 — before any other changes.

The governance argument for GTM is equally important as the performance argument. Without a tag manager, every new marketing experiment means a developer touching theme.liquid and the tag accumulates forever. With GTM, you can audit active tags quarterly, pause unused ones instantly, and enforce a rule that no tracker fires during the critical path. Pair GTM consolidation with a clean GA4 implementation to avoid double-counting events while cutting JS weight.

PricingFree (GTM itself); 4–8 hours of setup and migration

ProsSingle script tag replaces dozens of inline trackers; enables conditional loading; centralizes governance

ConsGTM itself adds ~80 ms; misconfigured tags can fire more scripts than before; requires ongoing tag hygiene

VerdictEssential for any store running five or more third-party tracking pixels — the governance payoff compounds over time

Your store’s Lighthouse score, fixed on autopilot.

✓Audits your JS footprint across every page automatically
✓Flags render-blocking scripts and implements defer fixes
✓Monitors Core Web Vitals and SEO around the clock

2,000+

Merchants

+31 pts

Avg score lift

Countries

06Best for reducing parse and execute time on remaining JS

JavaScript minification and bundle splitting

Minification strips whitespace, comments, and verbose variable names from JavaScript files without changing what the code does. The savings per file are modest — typically 20 to 35% reduction in file size — but they compound across a theme that might ship 15 to 25 JS files. Shopify recommends keeping each JavaScript bundle under 16 KB; most unoptimized themes ship individual files at 80–200 KB. Tools like UglifyJS handle this automatically as part of a build process, while theme-specific tools like NitroPack apply it dynamically at the CDN layer.

Bundle splitting is the more advanced cousin: instead of one large JavaScript bundle, you split code into chunks that load only when the relevant feature is needed. A product page does not need the blog comment widget JavaScript; a collection page does not need the checkout upsell logic. Shopify’s native ES modules support makes bundle splitting achievable in modern themes without a custom build tool. On its own, minification moves Lighthouse scores 4 to 10 points; combined with defer/async and app removal, the cumulative effect is significantly larger. For a broader look at how JS performance ties into organic rankings, see our guide on Shopify SEO fundamentals.

PricingFree (manual via UglifyJS, cssnano); $29–$79/mo via automated tools like NitroPack

ProsReduces file size 20–40% without changing functionality; bundle splitting defers unused code paths

ConsSavings are cumulative rather than dramatic in isolation; needs repeating after theme updates

VerdictA solid mid-tier fix — meaningful gains when combined with defer/async, not a substitute for removing bloat at the source

07Best for deferring section-specific scripts until they are needed

Lazy-load below-fold JavaScript modules

The Intersection Observer API lets you load JavaScript for a page section only when that section enters the viewport, rather than loading everything on DOMContentLoaded. This is the native browser approach to lazy-loading not just images, but entire JS modules. A homepage carousel script that powers a section 1,800 pixels below the fold has no business loading during the critical path — it can wait until the user is within 200 pixels of it. The same logic applies to product review widgets, upsell recommendation blocks, size-guide modals, and video embeds.

Implementation looks like: wrapping each section’s script initialization in an IntersectionObserver callback tied to the section’s container element. Shopify’s Dawn theme already uses this pattern for some components; the optimization is extending it consistently across custom sections and app-rendered blocks. Stores implementing this across a complex homepage with five or more below-fold sections have recorded Total Blocking Time reductions of 200–450 ms, translating to 5 to 9 point mobile Lighthouse improvements. INP, the Core Web Vital that replaced FID in March 2024, is particularly sensitive to long JavaScript tasks on the main thread — lazy-loading JS modules is one of the most direct ways to improve it.

PricingFree (Intersection Observer API, native browser feature)

ProsZero library dependency; surgically defers JS for carousels, reviews, upsells until user scrolls near them

ConsRequires custom implementation per section; can cause visible pop-in if not implemented carefully

VerdictHigh-value for content-rich homepages and long-form PDPs — reduces Total Blocking Time significantly

08Best zero-effort cleanup for themes with bloated section libraries

Remove unused theme sections and shipped code

Every section a Shopify theme ships with — even if you never add it to any page — can contribute CSS and JavaScript to the page load. Themes from the Shopify Theme Store often ship 30 to 50 sections covering every conceivable use case: countdown timers, parallax hero videos, testimonial carousels, newsletter pop-ups, brand story sections, and more. If your homepage uses six sections, the other 44 are dead weight. Shopify’s theme architecture means unused sections do not always tree-shake cleanly from the build.

The cleanup is straightforward in the theme editor: audit which sections are actually in use across your published pages, then remove the templates and snippet files for sections you will never use. Pay particular attention to JavaScript-heavy sections — video backgrounds, animated counters, parallax effects, and multi-step form builders are common culprits. Also check theme.liquid for global script includes that were added for a specific section but never scoped to conditional loading. This cleanup alone typically moves Lighthouse scores 3 to 8 points and meaningfully reduces the number of Lighthouse diagnostics flagged as opportunities.

PricingFree (30–60 minutes of admin work)

ProsEvery removed section eliminates its associated CSS and JS from every page load; no code skills required

ConsGains are modest compared to app removal; some sections re-appear after theme updates

VerdictA quick housekeeping win — do it once during setup and after every major theme update

09Best for unblocking hero render from the JavaScript queue

LCP image preload with fetchpriority=high

Reducing Shopify theme JavaScript for better Lighthouse scores is half the equation on LCP. The other half is making sure the hero image — the Largest Contentful Paint element on most Shopify homepages — is not queuing behind JavaScript downloads. Adding a <link rel="preload"> tag in the <head> with fetchpriority="high" tells the browser to request that image immediately, in parallel with HTML parsing, before the resource is discovered in the DOM. This is particularly powerful because most Shopify hero images are rendered via Liquid and discovered late in the parse cycle.

The implementation in a Shopify theme looks like conditionally outputting the preload link only on the homepage template (where the hero exists), using Shopify’s image_url filter to generate the correct CDN URL. Pair this with loading="eager" on the hero image itself and loading="lazy" on every image below the fold. Stores applying this alongside JS defer fixes have recorded LCP improvements of 600 ms to 1.4 seconds on mobile, contributing 4 to 7 additional Lighthouse points on top of the JS reduction gains. This is also the fix most likely to move your store’s real-user CrUX data, which Google uses for ranking signals, faster than lab scores alone.

PricingFree (1–2 hours of theme code work)

ProsDirectly improves LCP, Shopify's most commonly failing Core Web Vital; measurable on first audit after deploy

ConsAddresses LCP metric specifically rather than overall JS bloat; only one image should get this treatment

VerdictAn essential pairing with JS reduction — the hero image and the JS load race each other; win both to maximize score

10Best for preventing JavaScript regressions after every update

Lighthouse CI in deployment pipeline

Lighthouse CI is Google’s open-source tool for running Lighthouse audits automatically as part of your CI/CD pipeline. You set performance budgets — for example, mobile score must not drop below 65, Total Blocking Time must stay under 200 ms, no new render-blocking resources — and the pipeline fails if a proposed change violates them. This is the fix that makes all the other fixes durable, because the biggest reason Shopify stores regress on Lighthouse is that a developer installs a new app or a theme update ships a new globally-loaded script and nobody notices until a customer complains about load time.

Setting up Lighthouse CI involves adding the @lhci/cli package to your theme repository, writing a lighthouserc.js config file with your budgets, and integrating with GitHub Actions or your preferred CI tool. Shopify’s developer documentation recommends using Lighthouse CI specifically to catch performance issues early in the development cycle. For agencies managing multiple Shopify stores, it is also the most scalable way to maintain performance SLAs across a client portfolio. Combined with technical SEO monitoring, it creates a full-stack protection layer for both speed and search visibility.

PricingFree (open-source); hosted options from $0–$49/mo

ProsCatches performance regressions before they reach production; creates accountability for theme and app changes

ConsRequires engineering setup; adds to deployment time; thresholds need tuning to avoid alert fatigue

VerdictThe right final layer for stores that have done the hard work — protect your score from eroding with every new app install

Tom K.

Head of ecommerce
DTC Supplements Brand

★★★★★

“

Our mobile Lighthouse score was stuck at 28. We’d tried image compression and got nowhere. Ryze audited our JS footprint, flagged six render-blocking scripts we didn’t know were loading, and fixed them. We hit 67 in three weeks and organic traffic climbed 22%.”

+39 pts

Lighthouse lift

3 weeks

Time to result

Dev hours spent

How do you choose the right JavaScript reduction strategy for your store?

With 10 approaches from free manual fixes to autonomous AI tooling, the right starting point depends on your current score, your team’s technical level, and how much time you can invest before needing results.

Decision 1

What is your current mobile Lighthouse score?

Below 40: Start with app audit and removal — it is almost certainly the biggest lever at this score range
40 to 60: Add defer/async to render-blocking scripts and consolidate trackers into GTM
60 to 75: Focus on minification, lazy-loading below-fold modules, and LCP image preload
Above 75 and want to maintain it: Implement Lighthouse CI and let Ryze AI monitor for regressions

Decision 2

How much developer resource do you have?

No developer: Ryze AI autonomous audit, app removal (admin-level), and switching to Dawn require no coding
Occasional developer access: Add defer/async, LCP preload, and GTM consolidation to the list
In-house dev team: All 10 approaches are on the table — prioritize by score impact per hour of effort

Decision 3

Do you need the fix to last, or just pass an audit?

One-time audit pass: Manual app removal and defer/async fixes will move the score quickly
Durable improvement: Combine Ryze AI continuous monitoring with Lighthouse CI in your deploy pipeline
Agency managing multiple stores: Lighthouse CI budgets plus Ryze AI give you scalable, client-reportable performance governance

The bottom line: reducing Shopify theme JavaScript for better Lighthouse scores is most effective when approached in order — remove the biggest JS sources first (apps, legacy themes, synchronous trackers), then optimize what remains (defer, minify, lazy-load), then protect your gains (Lighthouse CI, autonomous monitoring). Most stores with a score below 50 on mobile can reach 65 to 75 by combining app audit, defer fixes, and GTM consolidation in a single sprint. Ryze AI is the only option in this guide that does all three continuously, without requiring you to re-do the work after every theme update or new app install. Pair it with a site speed audit to baseline your current state before starting.

1,000+ marketers use Ryze

Automating hundreds of agencies

★★★★★4.9/5

Frequently asked questions

What is a good Lighthouse score for a Shopify store?

A mobile Lighthouse score of 70 or above is considered good; 90+ is excellent. The average Shopify store scores between 30 and 55 on mobile — meaning most stores have significant room for improvement. A properly optimized theme with clean code, compressed images, and a minimal app footprint should target 70+ on mobile and 85+ on desktop. Ryze AI users average a 31-point improvement within 6 weeks.

How much does JavaScript slow down a Shopify store?

Significantly. Each installed app adds 50–200 ms of JavaScript overhead per page load. A store with 12 apps can accumulate over 1.5 seconds of JS execution time before rendering begins. JavaScript is the largest contributor to slow Shopify stores in 2026, ahead of unoptimized images. Reducing Shopify theme JavaScript for better Lighthouse scores is the highest-leverage optimization most stores have not done properly.

Does Shopify's Dawn theme really improve Lighthouse scores?

Yes, substantially. Dawn is built on an HTML-first, JavaScript-as-progressive-enhancement philosophy with no jQuery dependency. On a clean install with no apps, Dawn typically scores 65–80 on mobile Lighthouse — one of the highest baselines available. Stores migrating from jQuery-dependent themes to Dawn have seen 10–25 point score improvements on the homepage before any further optimization.

What is the difference between defer and async on script tags?

Both prevent render-blocking, but they execute differently. defer runs the script after HTML parsing completes but before DOMContentLoaded — preserving execution order. async runs the script immediately once it finishes downloading, regardless of parsing state — execution order is not guaranteed. Use defer for most theme scripts; use async only for fully independent scripts (like analytics) that have no dependencies on other scripts.

Will improving my Lighthouse score help my Shopify SEO rankings?

Yes, directly. Google uses Core Web Vitals (LCP, INP, CLS) as ranking signals via the Page Experience update. A poor mobile Lighthouse score almost always reflects poor Core Web Vitals in real-user data (CrUX), which feeds directly into Google's ranking algorithm. Stores that improve from a score of 35 to 75 routinely see organic traffic improvements of 15–30% within 60–90 days, on top of the conversion rate gains from faster load times.

How do I find which JavaScript is slowing my Shopify store?

Open Chrome DevTools (F12), go to the Network tab, filter by JS, reload the page in incognito mode, and sort by size or transfer time. The Lighthouse tab gives you an automated audit with specific Opportunities and Diagnostics. For a more detailed view, the Coverage tab shows exactly which JavaScript is executed versus dead code on each page. Ryze AI automates this audit continuously across all your pages, not just the homepage.

Fix your Shopify Lighthouse score with AI

#1 approach · autonomous · free trial