Frequently Asked Questions

Shopify CRO (Conversion Rate Optimization) is the systematic process of increasing the percentage of store visitors who complete a purchase. Unlike a redesign, CRO never starts from aesthetic preference. It starts from session recordings, GA4 funnel drop-offs, and heatmaps, then ships small, measurable changes to the highest-friction screens. The average Shopify store converts at 1.4%; top-quartile stores hit 3.3%. Moving from 1.4% to 2.1% on a $1M store is roughly $500K in extra revenue at the same traffic level. CRO is leverage on traffic you've already paid for.

A redesign rebuilds the storefront based on taste, trends, or a new brand direction. CRO rebuilds specific elements based on evidence that those elements are losing money. I've seen $40K redesigns drop conversion 18% because the agency moved the ATC button below the fold on mobile and removed trust badges the old theme had. A redesign is a creative project; CRO is an engineering project with a P&L attached. If your agency can't show you the funnel data behind every change, you're paying for a redesign and calling it CRO.

A proper Shopify CRO audit covers eight layers: GA4 funnel analysis, heatmaps and session recordings (Hotjar or Microsoft Clarity), Lighthouse and Core Web Vitals scoring, mobile-specific UX review (mobile is 70%+ of Shopify traffic), checkout friction map, app bloat assessment, theme code review for hardcoded prices and broken Liquid filters, and competitive benchmarking. Output should be a prioritized backlog of 30-50 issues scored by impact, effort, and confidence (ICE framework). Read the full framework in my 5-step CRO audit guide.

A thorough Shopify CRO audit takes 8-15 business days for a sub-$1M store and 3-5 weeks for a Shopify Plus store doing $10M+. The variance comes from data depth: more SKUs, more international markets, and more apps mean more surface area to test. I usually need 14 days of session recordings minimum before drawing conclusions. Anyone selling a 48-hour CRO audit is running a checklist, not analyzing your store. A real audit costs $1,500-$5,000 depending on scope.

Realistic Shopify CRO engagements deliver 15-40% lift in conversion rate over 90 days, with mature stores at the lower end and neglected stores at the higher end. A store converting at 1.2% with obvious mobile bugs can hit 2.0% in six weeks. A well-optimized Plus store at 3.5% might gain 0.4 points in a quarter, which still pays for itself 10x over at scale. Anyone promising to double your conversion in 30 days is either lying or working on a store so broken it shouldn't be live.

Measure CRO ROI as (incremental revenue minus consultant cost) divided by consultant cost, calculated on rolling 90-day windows. To isolate the CRO effect, compare conversion rate by device and traffic source against the pre-engagement baseline, controlling for seasonality and ad-spend changes. A $5,000 sprint that lifts conversion from 1.5% to 1.9% on a store doing 50K monthly sessions at $80 AOV adds roughly $16K monthly revenue, paying back in under two weeks. Track the metric, not the deliverable count.

Hire a Shopify CRO consultant when you're spending $5K+/month on paid ads and converting under 2%, or when revenue has plateaued despite traffic growth. Below $30K/month in revenue, your time is better spent on traffic acquisition and product-market fit. Above $100K/month, every 0.1% conversion lift is worth $1K+/month, which justifies $3K-$10K consultant fees easily. The clearest signal: GA4 shows healthy traffic but checkout abandonment above 75%.

Yes, for stores under $50K/month. Install Microsoft Clarity (free), enable GA4 enhanced ecommerce, run Lighthouse on your top three pages, and watch 50 mobile session recordings. You'll find 80% of your friction in two hours: tiny ATC buttons, broken variant pickers, slow image loads, missing trust signals at checkout. The free tools are excellent. What you can't DIY is interpretation under pressure and prioritization across 40 simultaneous issues.

The free Shopify CRO toolkit: Microsoft Clarity for heatmaps and recordings (uncapped), Google PageSpeed Insights, GA4 with enhanced ecommerce, Shopify's built-in conversion funnel report, Chrome DevTools Lighthouse, and my own free tools: CrUX Grader, App Bloat Detector, and Hardcoded Price Detector. I run paid client audits using 90% free tools.

Top Shopify CRO mistakes I see weekly: hardcoded prices in Liquid (breaks Markets currency conversion), 30+ installed apps slowing TTFB to 2s+, mobile ATC button below the fold, missing image_url width parameter causing CLS, no trust badges at checkout, page builders bloating LCP to 4s+, and review widgets loaded synchronously above the fold. Each one is a 2-8% conversion rate killer in isolation. Stack three of them and you've cut your conversion rate in half versus what the store could do clean.

Yes, measurably. Every Shopify app injects scripts; 25+ apps typically pushes Largest Contentful Paint past 4 seconds on mobile. Google's research shows conversion drops 4.42% for each additional second of load time between 0-5 seconds. I've audited Plus stores with 60+ active apps where uninstalling 20 unused ones lifted conversion 11% in two weeks with zero other changes. Run the App Bloat Detector to see your TBT damage.

A/B testing is one tactic inside CRO, not a synonym for it. CRO covers research, hypothesis-building, design, code, and measurement; A/B testing only handles measurement. You need A/B testing once you have enough traffic to reach statistical significance, which on Shopify means roughly 10,000 sessions per variant per week minimum. Below that, you're better off shipping evidence-led changes directly and measuring before/after on 4-week windows.

For statistically valid A/B tests on Shopify, you need roughly 5,000-10,000 conversions per variant to detect a 10% lift at 95% confidence. At a 2% conversion rate, that's 250,000-500,000 sessions per variant. Stores doing under 50,000 monthly sessions should not run A/B tests; you'll either ship false positives or kill winning variants by ending tests early. Use evidence-led shipping with before/after measurement on 28-day windows instead. Save A/B testing for $1M+ stores.

Completely different work. Sub-$500K stores need foundation fixes: theme speed, mobile ATC placement, trust signals, broken Liquid filters, app cleanup. The wins are obvious and large (20-40% lift). Shopify Plus stores at $10M+ have already fixed the obvious; CRO becomes statistical, segmented work focused on checkout flow, B2B pricing logic, multi-market currency handling, and personalization. Lifts are smaller (3-8%) but worth more in absolute dollars.

LCP (Largest Contentful Paint) must be under 2.5s, INP (Interaction to Next Paint) must be under 200ms, and CLS (Cumulative Layout Shift) must be under 0.1. These are the "good" thresholds. The 75th percentile of real-user data over a rolling 28-day window must hit them for a URL to pass. INP replaced FID in March 2024 and is the metric most Shopify stores currently fail.

Lighthouse runs a synthetic test on a throttled mid-tier Android with a cold cache, while CrUX (Chrome User Experience Report) is real Chrome users, mostly on faster devices, with warm caches. Google ranks on CrUX, not Lighthouse. A Shopify store can score 38 in Lighthouse and still pass all three Core Web Vitals in CrUX. Don't chase Lighthouse 90+ if your CrUX is green. Read more in my Lighthouse vs CrUX deep-dive.

Identify the LCP element (usually the hero or first product image), then apply four fixes: add loading="eager" and fetchpriority="high" to that image, preload it with a <link rel="preload" as="image" imagesrcset="..."> in the head, generate a responsive srcset via the image_url filter, and never lazy-load above-the-fold images. Most Shopify themes ship the LCP image as loading="lazy" by default, which alone can cost 800ms on mobile.

INP is almost always caused by long JavaScript tasks blocking the main thread when a user clicks a variant picker, swatch, or quantity button. Fix it by deferring all non-critical scripts, wrapping analytics calls in requestIdleCallback, debouncing variant change handlers, and removing apps that inject synchronous third-party scripts. Target INP under 200ms. Apps like reviews, upsells, and currency converters are the usual suspects. Run the App Bloat Detector to see which apps own your TBT.

Five common culprits: images without explicit width and height attributes, currency converter widgets that swap prices after load, review star ratings that inject after first paint, sticky headers that resize on scroll, and font swaps without metric-matched fallbacks. Fix it by always rendering images via image_tag (auto-adds dimensions), reserving space for review widgets with a min-height placeholder, and loading currency converters with a fixed-width skeleton.

Shopify's TTFB is mostly out of your hands, but you can make it worse. The biggest self-inflicted causes are bloated theme.liquid with synchronous app blocks, Shopify Markets generating extra redirects on geo-detection, custom checkout.liquid running expensive Liquid loops, and OS 2.0 sections with deep nested includes. Target TTFB under 800ms. Audit your theme with shopify theme check and look for any Liquid file over 500 lines.

Google ranks on CrUX (field data), not Lighthouse (lab data). Page experience is a confirmed ranking signal, but the data comes from real Chrome users via the Chrome User Experience Report, aggregated at the 75th percentile over 28 days. Lighthouse is a developer diagnostic tool, useful for finding what to fix, but its score has zero direct ranking impact. Check your real CrUX status in Search Console under Core Web Vitals.

Plan for 28 days minimum. CrUX uses a rolling 28-day window of real-user data aggregated at the 75th percentile, so even a perfect fix deployed today won't fully reflect for four weeks. You'll see directional movement in PageSpeed Insights' field data section after about 7-10 days, but Search Console's Core Web Vitals report updates more slowly. Don't panic-revert a fix because CrUX hasn't moved in week one.

Apps inject third-party JavaScript that runs on every page, often render-blocking and rarely deferred. A typical Shopify store with 15 apps loads 800KB-1.2MB of third-party JS, adds 200-400ms of TBT, and triggers 30+ extra DNS lookups. Each app's script runs with no shared dependency tree. Audit with the Network tab filtered by domain, then uninstall every app you don't actively need. Deactivation is not enough; the script tags often remain.

Use the Online Store > Performance dashboard for store-level CrUX trends, Theme Inspector (Chrome extension) for Liquid render profiling, shopify theme check CLI for static linting, PageSpeed Insights for combined Lighthouse + CrUX, and Search Console's Core Web Vitals report. Skip GTmetrix and Pingdom; they don't reflect what Google measures. For a Shopify-aware version of PSI with Liquid fix snippets, run my CrUX Grader.

No, you can't, and you shouldn't try. Shopify uses Fastly globally and routes all traffic through their own edge. They block CNAME flattening to third-party CDNs at the platform level, and putting Cloudflare in front breaks SSL, checkout, and the Shop Pay token flow. The CDN is included; what you control is what you serve through it. Optimize asset sizes and use the image_url width parameter aggressively.

Mobile. Google's mobile-first index means CrUX mobile data is what determines your ranking signal, even if 60% of your traffic is desktop. Always test on a throttled mid-tier Android (Moto G Power profile in Lighthouse), not your MacBook. Mobile LCP is typically 1.5-2x slower than desktop on the same Shopify theme due to image sizes, slower CPU parsing JS, and 4G latency.

Yes, but modestly. Page experience (which includes CWV) is a confirmed Google ranking signal, but it's a tiebreaker, not a primary factor. Content relevance, backlinks, and intent matching outweigh it. That said, passing CWV correlates with higher conversion rates, lower bounce rates, and better crawl efficiency. Sites that move from failing to passing typically see 5-15% organic traffic lift over 60-90 days, mostly from improved engagement metrics.

Open Chrome DevTools, go to the Performance panel, hit record, reload the page, stop, then look at the Timings track for an "LCP" marker. Click it and DevTools highlights the exact element. Alternatively, use the Lighthouse panel and expand the "Largest Contentful Paint element" audit. On most Shopify product templates, it's the main product image; on collection pages, it's the first product card image; on home, it's the hero banner.

Reserve the space before the widget loads. Wrap the widget container in a div with explicit min-height matching the rendered size: 24px for inline stars, 200px+ for full review blocks. Most review apps inject async and shift everything below them. The reservation costs nothing and eliminates the shift entirely. Same pattern works for currency converters, badge apps, and trust-seal widgets, anything that mounts after first paint.

Shop Pay converts at roughly 1.72x the rate of guest checkout, according to Shopify's published commerce data covering 10M+ orders. The lift comes from three mechanisms: pre-filled shipping and payment data, biometric authentication replacing password entry, and a single-screen confirmation flow. On mobile the gap widens further (about 1.91x) because keyboard friction is higher. If you do nothing else this quarter, enable Shop Pay and surface the accelerated checkout button on cart and PDP.

Prioritize Shop Pay first because it works across iOS, Android, and desktop, and it's the only wallet that remembers data across every Shopify store the shopper has used. Apple Pay second, since iOS still drives 55-65% of US DTC traffic. Google Pay third for Android coverage. Stack all three above the fold in cart drawer and checkout. Don't hide them behind a "more options" toggle; every extra tap costs 3-5% conversion on mobile.

Average DTC cart abandonment is 70%. Five fixes recover 15-25% of those: remove every non-essential field (each one drops completion 2-4%), show total shipping cost on cart (surprise fees cause 49% of abandonments per Baymard), enable guest checkout (forced account creation kills 24%), add wallet buttons above the fold, and display trust signals near the pay button. Read the full playbook in my checkout optimization guide.

Forcing account creation before purchase causes 24% of all cart abandonments (Baymard 2024). Shopify enables guest checkout by default, but many merchants accidentally disable it via Settings > Checkout > "Customer accounts: Required". Switch it to "Optional" or "Show login link" instead. You can still capture the email through the marketing consent checkbox, that's GDPR/CAN-SPAM compliant and gets 60-70% opt-in rates without the friction.

Checkout extensibility is Shopify's replacement for checkout.liquid, built on React-based UI extensions, Shopify Functions, web pixels, and branding APIs. It runs on Shopify's hosted infrastructure (not your theme), which means PCI-compliant, edge-rendered, and load times around 0.6-0.8s vs 1.5-2.5s on legacy. Customizations are sandboxed, so a broken app can no longer take down checkout. This is now the only path forward.

Shopify deprecated checkout.liquid for the Information, Shipping, and Payment pages on August 28, 2024. The Thank You and Order Status pages followed on August 28, 2025. After those dates Plus stores still on checkout.liquid lose access to upgrades, security patches, and new Shop Pay features. Migrate to Checkout Extensibility immediately. Read my Plus checkout optimization guide for the migration playbook.

Shopify Scripts (the Ruby-based discount/shipping/payment customization layer for Plus) is deprecated on August 28, 2025 for new installs and fully sunset June 1, 2026, after which existing Scripts stop executing. The replacement is Shopify Functions, written in Rust, JavaScript, or TypeScript and compiled to WebAssembly. Functions run at the edge in under 5ms vs Scripts' ~50-100ms, and they're version-controlled in your codebase. See my 5 real Script-to-Function migrations.

Shopify's default is a three-step checkout (Information, Shipping, Payment). One-page checkout is available on Plus via extensibility and reduces perceived friction, especially for repeat buyers. Tests across DTC brands show one-page lifts conversion 5-10% on desktop but is roughly flat on mobile, because the long scroll triggers form fatigue. Recommendation: keep three-page on mobile with progress indicator, switch to one-page on desktop.

Discount codes require the shopper to enter a code, which causes 8-12% of carts to abandon while they search Honey or Google for one. Automatic discounts apply silently at cart and remove that exit point. Use codes for influencer/affiliate attribution and email exclusives. Use automatic discounts for sitewide promos, BOGO, tiered cart value, and free gifts. On Plus you can stack multiple automatic discounts via Shopify Functions.

Set the threshold 30-40% above your AOV. If AOV is $52, set free shipping at $75. Brands that do this see AOV climb 15-30% within 60 days because shoppers add items to "unlock" free shipping. Show a progress bar in cart: "You're $13 away from free shipping". Don't set it below AOV (you'll just give away margin). Don't set it 2x AOV (shoppers won't bother and abandonment rises).

Mobile checkout fails on five things: missing input type="email" and inputmode="numeric" so the wrong keyboard appears, missing autocomplete attributes so browser autofill doesn't work, tap targets under 48px, no sticky pay button so users hunt for it, and an expanded order summary that forces extra scroll. Shopify's default checkout handles most of these, but custom themes and apps frequently break them.

Some do, most are noise. What works: SSL/lock icon near the pay button (lifts CVR ~5%), "30-day returns" microcopy (3-7% lift), recognizable payment logos, and review snippets from a verified source. What doesn't work: generic "100% secure" stock badges, McAfee/Norton seals (most shoppers don't recognize them anymore), and stacked badge walls that scream "trying too hard". Every badge should answer a specific objection.

Plus is $2,300/month (or 0.4% of revenue, capped at $40K/month for high-volume). It pays back when you hit $1M-$2M annual revenue and need at least two of: B2B, checkout customization beyond branding, Shopify Scripts/Functions, multi-store (up to 9 expansion stores), Launchpad, or higher API limits. Below $800K revenue the math rarely works. Above $3M with custom checkout or B2B needs, Plus is non-negotiable.

Post-purchase upsells appear on a dedicated page after payment but before the thank-you screen, letting shoppers add items in one click without re-entering payment. Built via Checkout UI Extensions on Plus. Typical AOV lift is 8-15% with conversion rates of 5-12% on the upsell offer. Keep it to one offer (two max), complementary to the original purchase, and time-limited (60-second countdown drives urgency). Sweet spot is 20-40% of original order value.

Shopify Plus B2B ships native B2B checkout with company profiles, NET 15/30/60 payment terms, customer-specific catalogs, volume pricing, and tax-exempt flows. It runs on the same checkout extensibility infrastructure as DTC, so customizations port across. Customer Accounts (the new login) replaces classic accounts and is required for B2B buyers to access their company's pricing and invoice history. Setup typically takes 15-25 hours for a basic catalog plus tax/payment terms config.

Liquid is Shopify's open-source templating language, written in Ruby, that turns theme files into rendered HTML. It uses two delimiters: {{ output }} for printing values and {% logic %} for control flow. Liquid is sandboxed, so it cannot touch the filesystem or run arbitrary Ruby. Every storefront page is a Liquid template that pulls from global objects like product, collection, and cart.

A developer who already knows HTML, CSS, and a templating language can be productive in Liquid within a weekend. The syntax is small: ~30 tags, ~60 filters, and a fixed set of global objects. The real curve is Shopify's domain model, OS 2.0 sections, metafields, and theme architecture conventions, which usually takes 2-4 weeks of project work. Plan a month before quoting client work; six months before calling yourself senior.

Stay on Liquid for 95% of merchants: faster to ship, native theme editor, app ecosystem just works, hosting included. Go Hydrogen when you need a true SPA, complex personalisation, a content-heavy site driven by a third-party CMS, or shared components across web/native. Headless trades the editor and one-click app installs for engineering control. Below ~$5M GMV, the ROI almost never justifies it.

Vintage themes use .liquid template files with sections only on the homepage and a fixed structure. OS 2.0 (launched 2021) uses .json template files where every page is built from sections and blocks the merchant can reorder. OS 2.0 also unlocks app blocks, dynamic sources for metafields, and theme-wide section groups. Always start new builds on OS 2.0. Vintage is now legacy.

Sections are full editor-controlled units with their own {% schema %} and settings. Snippets are reusable Liquid partials with no schema, called via {% render 'name' %}, perfect for DRY chunks. Blocks live inside a section's schema as repeatable child items the merchant can add/remove/reorder. Rule of thumb: section if it stands alone on a page, block if it repeats inside a section, snippet if it has no merchant-facing settings.

{% render %} replaced {% include %} in 2020 and the include tag is deprecated. Render runs in an isolated scope, so the snippet only sees variables you pass explicitly: {% render 'product-card', product: product %}. The isolation prevents accidental variable leakage and lets Shopify cache snippets independently, which speeds up complex loops. Always use render in new code.

Yes. Shopify allows raw HTML, CSS, and JavaScript inside the Custom Liquid section type, including inline script tags and references to external scripts. The Custom Liquid block uses an html setting under the hood, and Shopify renders that content into the page without sanitizing script tags out. Read my deep-dive on Custom Liquid script tags for the 4 patterns that actually run.

Metafields attach extra data to a single existing resource (product, variant, collection, customer, order). Use them for one-off attributes. Metaobjects are standalone custom content types you define yourself: think Designer, Lookbook, Size Guide. They have their own fields, can be referenced from multiple resources, and have list/detail pages. Metafield = property of something. Metaobject = its own thing.

image_url generates a CDN URL with transformations: {{ product.featured_image | image_url: width: 800 }}. Always pass width (and optionally height, crop, format) so Shopify serves the right size. Pair with image_tag for full <img> output with srcset, sizes, alt, and lazy loading. Never hardcode cdn.shopify.com URLs; you lose the responsive pipeline and break when the CDN domain changes.

{{ 1999 | money }} outputs $19.99 using the shop's HTML money format. {{ 1999 | money_with_currency }} outputs $19.99 USD, useful in carts and checkout where currency clarity matters. money_without_currency strips the symbol entirely. Prices in Liquid are always integers in cents. Never divide by 100 manually and concatenate a symbol; it breaks for markets with comma decimals and multi-currency stores.

Append ?section_id=variant-picker to any storefront URL and Shopify returns just that section's rendered HTML, no full page reload. Power pattern for variant pickers: when the user picks a swatch, fetch /products/handle?variant=12345&section_id=main-product, swap the price and gallery DOM, push state. Same trick powers cart drawers and predictive search results. Cuts a 200ms full-page render down to a 30ms partial.

Shopify CLI is the official tooling: shopify theme dev spins up a local server with hot reload, shopify theme push deploys, shopify theme pull syncs settings down. Theme Check is the linter (built into the CLI and the VS Code extension) that catches deprecated tags, missing translations, asset size warnings, and unused snippets. Run it in CI to block merges that ship {% include %} or oversized images.

Dawn is Shopify's reference OS 2.0 theme, MIT-licensed, vanilla JS only, no jQuery, no framework, ~85 mobile Lighthouse out of the box. Use it as the base for custom builds: it's audited, accessible (WCAG AA), and Shopify keeps it updated alongside platform features. Drawbacks: minimal aesthetics by design (you'll redesign 80% of CSS) and the JS uses web components. Fork Dawn over any premium theme when you need full control.

Liquid loops cost real server time. Always cap with limit:, use paginate for anything over 50 items, and avoid nested loops over all_products. Cache repeated work in variables. Move heavy filtering to JSON via {{ collection.products | json }} and let the client filter. Hard cap: 50 product object accesses per page, more triggers Shopify's resource limit error. See my Liquid loop optimization guide.

Liquid has no operator precedence. Conditions evaluate strictly right to left: {% if a or b and c %} parses as a or (b and c). There are no parentheses to override this, so split complex logic into multiple {% if %} blocks or precompute booleans with {% assign %}. Variables are immutable per render scope; reassigning creates a new binding.

Never edit the published theme directly. Every save is instant in production: a missing closing tag breaks checkout, a typo in money filter breaks every price. Workflow: duplicate the live theme, rename it dev-YYYY-MM-DD, edit there, preview via the share link, QA on real devices, then publish to swap. Better still, run shopify theme dev locally against a dev theme, push to staging, get sign-off, publish.

App bloat is the cumulative performance, code, and cost overhead from running too many third-party Shopify apps, especially ones that inject JS, CSS, and Liquid into every page load. Each app typically adds 50-300ms of Total Blocking Time, 30-150KB of JS, and one or more render-blocking requests. Bloat compounds. Run the App Bloat Detector to see exactly what each app on your store is loading.

A healthy Shopify store runs 5-10 apps maximum. Anything over 15 usually signals bloat, conflicting scripts, and a mobile Lighthouse score under 50. The Shopify 2025 Plus benchmark stores average 7 apps. Keep apps that touch payments, fulfilment, email/SMS, subscriptions, and tax/accounting. Cut anything UI-only and rebuild it in Liquid. Each removed UI app typically saves 80-200ms TBT.

Keep apps handling complex backend logic: Klaviyo (email/SMS), Recharge or Skio (subscriptions), Shopify Payments, Avalara (tax), ShipStation, Gorgias. Replace UI-only apps with Liquid: countdown timers, trust badges, sticky ATC, FAQ accordions, image galleries, size charts, and recently viewed. The rule: if the app's only job is rendering HTML/CSS, you should rebuild it. See 15 Liquid snippets that replace apps.

Yes, for most stores. Klaviyo adds ~120ms TBT and ~85KB of JS on first paint, which is significant but justified by ROI: email/SMS typically drives 25-35% of revenue. The fix is scoping. Don't load Klaviyo's full SDK on every template; load it only on cart, checkout, and pages with onsite forms. If you're under $50K/month and Klaviyo flows aren't yet ROI-positive, switch to Shopify Email until volume justifies the upgrade.

Judge.me is the lightest mainstream review app at ~80ms TBT and 35KB JS, and starts free. Loox adds ~130ms TBT but ships better photo/video review UI. Stamped sits around 180ms TBT. Yotpo is the heaviest at ~250ms TBT plus 140KB+ JS. For most stores under 50K orders/year, Judge.me wins on price and performance.

Skio is the modern winner: native Shopify Checkout integration, ~70ms TBT, clean dashboard, and merchant-friendly pricing (1% + $0.20). Recharge is the legacy incumbent with the deepest feature set but adds ~140ms TBT and breaks Shop Pay on some setups. Loop is mid-weight (~110ms TBT) with strong retention tooling. Bold Subscriptions is the heaviest at ~190ms TBT and is increasingly outdated.

Yes, severely. Shogun adds ~320ms TBT and 180KB JS. PageFly adds ~280ms TBT. GemPages adds ~260ms TBT. They inject their own runtime, lazy-load engine, and CSS framework on top of your theme, often duplicating what your theme already does. They also lock content inside their database. Use page builders only if you genuinely need non-developers shipping landing pages weekly.

Currency converter apps work by intercepting every price element on the page, fetching exchange rates from an external API, and rewriting the DOM after paint. This causes layout shift (CLS spikes from 0 to 0.15+), 200-400ms TBT, and a flash of original currency before conversion. Use Shopify Markets instead, which handles currency natively at the Liquid level. Migration is usually under an hour.

Tidio is the lightest at ~110ms TBT but has weaker ticketing. Intercom adds ~180ms TBT and 95KB JS. Gorgias adds ~150ms TBT but ships a heavy widget that doubles in size when opened. The performance fix for any chat app is delayed loading: don't load the chat widget until the user scrolls 50% down the page or clicks a "Need help?" button. This single change saves 100-150ms TBT.

Google Tag Manager itself is light (~30ms TBT) but it loads everything inside it synchronously by default: Meta Pixel (~80ms), TikTok Pixel (~90ms), Hotjar (~140ms), Microsoft Clarity (~70ms). A typical GTM container with 6 pixels adds 400-500ms TBT. Fixes: load GTM with defer not async, fire pixels on consent only, use Shopify's native Customer Events API for Meta and TikTok instead of GTM injection.

In theme.liquid, wrap app embed renders in template conditionals: {% if template contains 'product' %}{% render 'app-block' %}{% endif %}. This stops review apps, sticky ATC, and product recommendation apps from loading on the homepage, blog, and policy pages where they do nothing. Scoping a single review app to product templates only saves ~150ms TBT on every non-product page.

No, not reliably. Uninstalling removes the app from your account but leaves behind: Liquid snippets installed via theme editor, app embed blocks in settings_data.json, hardcoded script tags in theme.liquid, leftover metafields, and webhook subscriptions. After every uninstall, search your theme files for the app's namespace, remove all matching renders and scripts. Skipping this step is the #1 cause of "I uninstalled it but the site is still slow".

Break-even math: a $30/month app costs $360/year, so a $1,500 custom Liquid replacement pays back in 4 years on subscription alone. Add the performance gain (typically 5-10% conversion lift on mobile from 100ms TBT recovery), and break-even drops to 6-12 months. Apps worth keeping: anything under $50/month doing complex backend work. Apps worth replacing: $30-99/month UI-only tools.

Yes for most cases. Privy, Justuno, OptiMonk, and Wisepops all add 80-180ms TBT and 40-90KB JS to fire a single email capture popup. A Liquid + 30 lines of vanilla JS exit-intent popup ships zero external requests, 2KB of code, and converts equally well. The exception: heavy A/B testing or behavioural targeting. See my popups killing conversions piece.

Shopify Markets is the unified internationalization layer Shopify rolled out in 2022 that replaces the legacy multi-currency setup. It bundles currency, language, domain, pricing, duties, and tax behaviour per region, and lets you serve a converted price on the storefront via the money filter. It also exposes localization.country and localization.language objects in Liquid so themes can adapt without third-party apps.

Markets converts prices through Shopify's pricing engine, which only triggers when prices flow through {{ product.price | money }} or money_with_currency. Any price typed as raw text in a section, metafield, or rich-text block (e.g. "$49.99") stays in the source currency forever, breaking the customer's market context. The fix is always to render prices through Liquid money filters. Run the Hardcoded Price Detector to find them all.

The money filter outputs the price in the buyer's active market currency using the format defined in Shopify admin. When Markets is active, Shopify auto-converts the base price using its FX rate plus any rounding rule you set per market. The filter never queries an API at runtime; conversion is baked into the rendered price object, so the only requirement is that prices originate from a Shopify price field, not a hardcoded string.

Flash of unstyled content on price happens when the theme renders the default-currency price server-side, then a JavaScript rewriter swaps it client-side after detecting the buyer's market. Shoppers see the wrong price flash, then the correct one. The root cause is themes that bypass the Liquid money filter or use cached fragments. The fix is letting Shopify's edge handle the conversion server-side via Markets. See the Everly Markets FOUC case study.

Shopify's free Geolocation app shows a dismissible banner suggesting the buyer's matched market, but never auto-redirects, which keeps SEO and UX clean. A manual selector in the header gives shoppers explicit control and avoids the trust dip of being silently relocated. Best practice is to combine both: a passive banner for first-time visitors plus a persistent country/currency dropdown.

Shopify auto-generates hreflang tags when you have multiple Markets with distinct domains or subfolders. The tags appear in <head> only if you've enabled "International domains" or subfolders inside Markets. Theme-level hreflang via Liquid is fragile because it can drift from Shopify's canonical map. Trust Shopify's auto-output, verify in Search Console, and avoid hardcoding hreflang in theme.liquid.

Subfolders (example.com/fr) consolidate domain authority and are now Shopify's default for Markets, requiring only one SSL cert and one Search Console property per language path. Subdomains (fr.example.com) split authority but are easier to host on separate platforms. ccTLDs (example.fr) signal strongest local intent but require separate SEO from scratch. For most Shopify Plus merchants entering 3-5 markets, subfolders win on speed, cost, and SEO equity transfer.

Markets Pro is Shopify's managed cross-border service that turns Shopify into the merchant of record for international orders. It handles duty and tax calculation, collection, remittance, fraud liability, and localized payment methods through a partnership with Global-e. You pay a transaction fee instead of building VAT/IOSS/duty logic yourself. Worth it for merchants doing meaningful international volume but unfamiliar with EU VAT rules or US-to-EU duty thresholds.

EU and UK shoppers expect prices to include VAT; US shoppers expect tax added at checkout. Shopify Markets handles this via the "Include or exclude tax based on customer's country" setting, which dynamically toggles the tax display per market. Pair it with "Charge tax on this product" at the variant level and accurate tax overrides for reduced-rate categories like books or children's clothing. Failing to localize tax display is the single biggest cause of EU cart abandonment from US-built stores.

Translate and Adapt is Shopify's first-party app, free for two languages, deeply integrated with Markets, and renders translations server-side with no JS injection. Weglot is a paid third-party with stronger automation and translation memory, but injects translations via a proxy layer that adds TTFB. Langify is older, theme-level, and slower to keep up with Shopify changes. For new builds, default to Translate and Adapt.

Inside Shopify admin, open Settings > Markets, select the market, and under "Currency and pricing" switch from "Auto-convert" to "Manual". This lets you set fixed prices per market via a CSV price list, useful when FX volatility breaks your margin or when a local distributor sets MSRP. Manual mode requires uploading prices for every product in that market's currency, but gives full control over psychological pricing.

Don't let raw FX conversion produce ugly prices like 47.83 EUR. Use Markets' price rounding rules to snap to .99 or .95 endings per market, and configure manual price adjustments where local price elasticity differs (e.g. premium pricing in Norway, value pricing in Poland). Round numbers signal trust and reduce cognitive load. Review quarterly, since FX drift can quietly break your psychological price points.

Yes, Shopify B2B integrates with Markets so you can run wholesale catalogs, NET payment terms, and customer-account-based price lists per region. Each B2B company location maps to a market, inheriting that market's currency, tax treatment, and shipping zones. Use customer accounts (the new version, not classic) and assign price lists via the B2B catalog feature. The combo lets you serve UK retail, EU retail, and EU wholesale from one store.

A proper Shopify CRO audit runs $500 to $2,500 depending on store size and depth. Quick audits ($500-$800) cover homepage, PDP, cart, and checkout with a prioritised fix list. Full audits ($1,500-$2,500) include heatmap review, GA4 funnel analysis, Lighthouse data, competitor benchmarking, and an ICE-scored roadmap. I deliver as a Notion doc plus a 30-minute walkthrough Loom so your team can action it without me on retainer.

Monthly Shopify CRO retainers typically sit between $2,000 and $8,000. At the lower end you get audit refreshes and 2-3 implemented fixes per month. At $5,000-$8,000 you get continuous testing, weekly implementation, GA4 reporting, and a roadmap that ships every two weeks. My retainers start at $2,500/month for stores under $500K/year revenue and scale based on test volume, not hours. Most clients sign 3-month minimums.

$50/hour, billed weekly with a tracker log. I prefer fixed-price for audits and defined sprints, where you know exactly what you are paying for. Hourly works for ongoing work, bug fixes, and unscoped exploratory tasks. For new clients I usually start fixed-price on a small scoped piece, then move to hourly or retainer once we trust each other.

Most engagements run 2 to 12 weeks. A one-time audit is 1-2 weeks. A full implementation sprint is 4-6 weeks. Ongoing CRO retainers are 3, 6, or 12 months. CRO is not a one-week job because tests need traffic, time, and statistical significance. If a store gets under 500 transactions per month, I usually recommend a fixed audit plus quarterly check-ins instead of a full retainer.

Look for four things. First, public proof: Upwork JSS, Top Rated badges, LinkedIn recommendations from real founders. Second, case studies with actual numbers, not vague "increased conversions". Third, a portfolio of live URLs you can audit yourself. Fourth, a 30-minute call where they audit your store live and tell you something you did not know. My Upwork profile is 4.96/5 across 100+ jobs with the receipts public.

Yes, and most of my clients are US, UK, AU, or EU based. I work GMT+6 and overlap 4-5 hours daily with US East Coast (their mornings), most of the UK day, and full overlap with Australia. Async-first is the default: Loom walkthroughs, Notion docs, Slack threads. Live calls happen 1-2 times per week on a fixed schedule. Twelve years remote-first means the workflow is already dialled in.

Upwork if you want escrow protection, dispute resolution, and a public track record you can verify. Direct hire if you want a lower rate (no Upwork fees) and faster invoicing. For first-time clients I always recommend Upwork because their payment protection is real and you can see verified earnings, hours, and reviews. After a successful engagement, most clients move to direct billing for repeat work.

Five things on day one: Shopify admin access as a Staff account with Themes, Products, Apps, and Analytics permissions, GA4 read access, Search Console read access, heatmap tool login if you have one, and a duplicate of the live theme so I never push to your published theme. Optional: ad platform access, Klaviyo read access, and your Notion or Linear so I can document inside your stack.

Yes. I sign mutual NDAs before any access is granted, no exceptions. Client work, revenue figures, internal docs, and store strategy stay private. My case studies are either anonymised or published with explicit written approval. I do not name clients on my portfolio without permission, do not screenshot dashboards, and do not reuse client code on other stores. If your team needs a specific NDA template, send it.

I implement. That is the difference between a CRO consultant and a CRO strategist. I write the Liquid, JS, and CSS, ship it on a development theme, QA across mobile and desktop, and push to production. Twelve years of Shopify dev means I am not handing your team a 40-page PDF and disappearing. If you have an in-house dev team, I can deliver scoped tickets in Linear or GitHub instead.

Four primary metrics: conversion rate (CVR), revenue per visitor (RPV), average order value (AOV), and Largest Contentful Paint (LCP). RPV is the most honest because it captures CVR and AOV together and removes traffic-quality noise. Secondary: add-to-cart rate, checkout completion rate, bounce rate on PDP, and Core Web Vitals. I report weekly in a shared Notion dashboard pulled from GA4 and Shopify Analytics.

Yes, and I do this often. The split usually works as: agency owns ads, creative, and email. I own storefront, PDP, checkout, and on-site CRO. Clear scope boundary, shared Slack channel, weekly sync. The friction point is usually code ownership: agencies hate when consultants push to a theme they manage. I solve this by working on a development theme, raising PRs in GitHub, and letting the agency dev review and merge.

Thirty minutes, no pitch. I audit your store live on the call, walk through the top 3-5 issues I see on PDP, cart, and checkout, and give you a rough estimate of effort and impact. You leave with two or three things you can fix yourself this week, even if you never hire me. No PDF, no follow-up sales sequence. Book it on the contact page.

Five reasons. First, the store has under 200 sessions per day (no traffic to test on). Second, the founder wants to A/B test their gut instead of data. Third, the brief is "make it convert better" with no defined goal or budget. Fourth, payment terms are 60+ days net. Fifth, the founder has worked with five consultants in the last year and fired all of them. I would rather pass on a bad-fit project than take it and underdeliver.

Full handover doc in Notion: every change made, every test result, every code snippet committed, with file paths and rollback notes. A 60-minute walkthrough call with your in-house dev or next consultant, recorded as a Loom for the team. Thirty days of free email support for bug fixes related to my work. After that, I am available for ad-hoc retainers or one-off sprints at standard rates.

Mobile typically converts 40-60% lower because of friction stacking: slower LCP (often 4s+ vs 2s desktop), cramped above-fold real estate hiding price and ATC, fat-finger tap errors on sub-44x44 targets, and checkout form fatigue. Most Shopify themes inherit a desktop-first DOM order, pushing reviews, trust badges, and ATC below 2-3 screens of scroll. See my mobile CRO guide for the full playbook.

Use sticky ATC on PDPs longer than 1.5 viewport heights, where the primary ATC scrolls out of view. It should appear only after the user passes the original ATC (IntersectionObserver, not scroll-Y math) to avoid duplicating buttons above-fold. Keep height under 64px so it doesn't eat content, include price and variant selector if space allows, and never show on cart, checkout, or collection pages. Expect 3-8% mobile CVR lift when implemented correctly.

Within the first 100vh on a 375px viewport you need: product title (max 2 lines, 18-22px), price with compare-at if discounted, hero image (square or 4:5, never taller than 100vw), 1-line trust signal (free shipping or returns), and visible ATC or "scroll for options" cue. Reviews summary should appear under the title. Skip the breadcrumb on mobile; it steals 40px of vertical space and nobody taps it.

Apple HIG and Google Material both specify 44x44px minimum, with 8px spacing between adjacent targets. On Shopify, the worst offenders are variant swatches (often 32x32), quantity selectors (28x28 +/- buttons), and footer links. Increase swatch hit area with padding, not width, so the visual stays compact while the tap zone expands. For text links in footers, set min-height: 44px with flex centering.

Use swatches for color and visual attributes (max 8 visible, then "+4 more"), pill buttons for size and short text variants, and dropdowns only when you have 10+ options or two-tier variants. Native select dropdowns trigger the iOS wheel picker which feels dated. Pill buttons at 44x44 with clear selected state outperform dropdowns by 5-12% on CVR. Always show out-of-stock variants greyed with strikethrough rather than hiding.

Native CSS scroll-snap beats Slick and Flickity on mobile in 2026: zero JS weight, 60fps swipe, accessible by default. Use scroll-snap-type: x mandatory on the container and scroll-snap-align: center on each slide. Slick is heavy (40KB+ with jQuery) and breaks pinch-zoom. Flickity is lighter but still 25KB. Reserve JS carousels for desktop where you need hover thumbnails.

Show the star rating and count above-fold next to the title. Full review block goes below the description, not in a tab, because tabs hide content from scroll-depth users and from Google. Aggregate reviews above-fold lift CVR 8-15% through trust anchoring. Avoid third-party widgets that load 200KB+; use their lightweight badge variants and lazy-load the full carousel.

The high-leverage trust signals on mobile, in priority order: free shipping threshold, return window, payment icons (Visa, Mastercard, Apple Pay, Shop Pay), star rating with count, and a single security badge if you sell high-AOV products. Stack them in a single 32-40px row under the ATC, not scattered. Avoid generic "100% Secure Checkout" badges; they look spammy and add no lift.

Yes for any 3+ card section. On mobile, a 3-card grid stacked vertically buries products 4+ scrolls deep, killing engagement. Use overflow-x: auto, scroll-snap-type: x mandatory, and 80vw card width so the next card peeks. No JS needed. Apply to: featured collections, related products, recently viewed, "shop by category". This pattern lifts collection page CTR 10-20% on mobile.

Modal wins on mobile. Inline size charts push the ATC further down the page, hurting CVR. Trigger with a "Size guide" link next to the size variant picker, opens a full-screen modal with the chart and fit notes. Modal should close on swipe-down (native iOS gesture) and have a 44x44 close button. For apparel and shoes, an accurate size chart can cut returns 15-25%.

Accordion wins on mobile. Tabs are a desktop pattern that breaks on narrow viewports and hide content from Google. Single-block descriptions push reviews and related products too far down. Use 3-5 accordions max: Description, Specs, Shipping, Returns, FAQ. Each header 48-56px tall, full-width tap zone, clear chevron indicator. Open the first accordion (Description) by default.

Cart drawer wins on mobile for single-item adds and upsells, but break to cart page for carts with 5+ items or when running line-item discounts. Drawer should slide from right (not bottom) on mobile, take 90% viewport width, and show: line items, subtotal, free shipping progress bar, and one upsell row max. Always include a "View cart" link to the full page for users who want detail.

Show both when you have meaningful express checkout. "Buy now" via Shopify's dynamic checkout button skips the cart and lands users in checkout, lifting one-product CVR 5-10%. Place "Add to cart" primary (filled, brand color) and "Buy with Shop Pay" secondary directly below. Never hide ATC behind Buy Now. For multi-product stores, de-emphasize Buy Now since it skips upsells.

Show a progress bar in the cart drawer ("$12 away from free shipping") with a filled bar visualizing progress. Lifts AOV 5-15%. Don't put the threshold message in the announcement bar at the top; it's banner-blind and steals 40px of viewport. On the PDP, a single line under the ATC ("Free shipping over $50") is enough. Once threshold is met, change to "You've unlocked free shipping".

Yes when stacked. A single 32-40px announcement bar is fine. Two stacked banners (announcement + cookie + email popup) eat 30% of mobile viewport before content loads, tanking LCP and CVR. Email popups on PDP load (not exit-intent) cut mobile CVR 8-15%. Test removing the announcement bar entirely for 2 weeks; most stores see flat or improved CVR.

Shopify handles the basics well: clean URLs, mobile-responsive themes, auto-generated sitemap.xml, server-side rendering, free SSL, and CDN-hosted assets. It auto-sets canonical tags, generates hreflang for Markets, and ships fast TTFB on Plus. Where it falls short: forced URL prefixes (/products/, /collections/), duplicate variant URLs via ?variant= params, /collections/all bloat, and theme-level H1 hierarchy issues. Solid foundation, but technical wins require Liquid edits.

Shopify auto-generates sitemap.xml at yourstore.com/sitemap.xml with child sitemaps for products, collections, pages, and blogs. In Google Search Console, add your store as a Domain property, verify via DNS TXT record, then go to Sitemaps and submit sitemap.xml. Only the root file needs submitting; Google discovers the children automatically. Note: only Basic plan and above expose sitemap.xml; Starter plans do not.

Yes, since June 2021. Create a robots.txt.liquid template under Online Store > Themes > Edit Code > Templates. Use the {%- for group in robots.default_groups -%} loop to extend Shopify's defaults, then add custom rules. Never wholesale-replace defaults; you'll break Shopify's checkout and cart blocks. Common adds: disallow /search, /*?*sort_by=, /*?*filter., and tag pages.

Shopify auto-injects <link rel="canonical"> via the {{ canonical_url }} object in theme.liquid's head. Product variant URLs (?variant=12345) canonicalise to the parent product. Collection-product URLs (/collections/foo/products/bar) canonicalise to /products/bar. Common bugs: themes that hardcode canonical, duplicate canonical tags from apps, or canonicals pointing to /collections/all.

Usually yes. Tag pages (/collections/{handle}/{tag}) are auto-generated and create thin, near-duplicate index bloat, especially on stores with 50+ tags. Add a noindex meta in theme.liquid scoped to tag templates: {%- if current_tags -%}<meta name="robots" content="noindex, follow">{%- endif -%}. Same approach works for /collections/vendors and unfiltered /search results.

Add BlogPosting JSON-LD to article.liquid. Required fields: @type, headline, image, datePublished, dateModified, author (with @type Person and name), publisher (Organization with logo as ImageObject), and mainEntityOfPage. Pull values from Liquid: {{ article.title }}, {{ article.created_at | date: '%Y-%m-%dT%H:%M:%SZ' }}. Use BlogPosting (not generic Article) to earn the article carousel. See my Article schema guide.

Required: @type Product, name, image, description, sku, brand. Strongly recommended: offers (with price, priceCurrency, availability, url, priceValidUntil), aggregateRating, and review. Pull from Liquid: {{ product.title | json }}, {{ product.featured_image | image_url: width: 1200 | json }}, {{ product.price | money_without_currency | json }}. Use {% if product.available %}InStock{% else %}OutOfStock{% endif %}.

Add FAQPage JSON-LD to the page template that renders the FAQ block. Wrap mainEntity as an array of @type Question objects, each with a name (the question) and acceptedAnswer (@type Answer with text). Only mark up FAQs visible on the page; hidden accordions are fine but cloaked content violates guidelines. Validate via Rich Results Test. Don't use FAQ schema on product pages; Google ignores it there.

Title tag: aim for 50-60 characters; Google truncates around 580 pixels. Meta description: 150-160 characters; mobile truncates at 120. Edit per page in Online Store > Preferences (homepage) or per product/collection/page/article via the SEO section. For dynamic title patterns, edit theme.liquid's <title> block. Customise the separator and brand suffix to match brand voice.

Most Shopify themes ship with multiple H1s per page (logo wrapped in H1, plus product title H1) or skip from H1 to H3. Audit by inspecting your theme.liquid, header.liquid, and product.liquid. Rules: one H1 per page, matching the page's primary topic. Logo should be a <div> or <a>, not H1. Run a Screaming Frog crawl with the H1 tab to find duplicates.

Go to Online Store > Navigation > URL Redirects > Create URL redirect. Enter the old path (relative, e.g., /products/old-handle) and the new path. Shopify auto-creates redirects when you change a product, collection, page, or article handle, accept the prompt to keep equity. Bulk-import via CSV with from/to columns. Avoid redirect chains (A > B > C); flatten to A > C.

Yes, CWV (LCP, INP, CLS) are confirmed Google ranking signals since 2021, weighted within the page experience cluster. Measure real-user data via PageSpeed Insights, GSC's Core Web Vitals report, or CrUX. Shopify-specific wins: use image_url width parameter to prevent CLS, defer non-critical JS, lazy-load below-fold images. Apps are usually the LCP killer; remove what you don't need.

Edit alt via Products > [product] > Media > Alt text. Keep alt under 125 characters, describe the image in context (not "product photo"), include the product name plus one descriptive attribute. Skip "image of" or "picture of"; screen readers add that. For decorative theme images, use alt="". In Liquid, render via {{ image | image_tag: alt: image.alt }} never raw <img src>.

Generative Engine Optimization (GEO) is the practice of structuring your store's content, schema, and product data so AI engines like ChatGPT, Perplexity, Gemini, and Google AI Overviews cite or recommend your products in generated answers. Unlike SEO, which targets ranked blue links, GEO targets extraction. Engines parse Product schema, FAQ blocks, review counts, and structured copy, then synthesise a response. See my Shopify GEO guide.

SEO optimises for crawlable HTML, backlinks, and ranking signals tied to a 10-blue-link SERP. GEO optimises for AI extraction: structured data, factual density, citation-worthy phrasing, and feed cleanliness. SEO rewards keyword targeting; GEO rewards declarative answers ("The Acme X9 weighs 2.3kg, ships in 24 hours, costs £49") that an LLM can lift verbatim. SEO uses Search Console; GEO uses GA4 referral filters for chatgpt.com, perplexity.ai, etc.

Five matter today. ChatGPT (with Shopping and Instant Checkout), Perplexity (Shop and Instant Buy), Google AI Overviews (pulled from the Merchant Center feed), Gemini (linked to Google Shopping), and Microsoft Copilot (Bing Shopping inventory). ChatGPT is the volume leader for product research; Perplexity converts well on considered purchases; AI Overviews capture top-of-funnel queries inside Google itself.

Agentic Storefronts is Shopify's framework, formalised in the April 2026 update, that lets AI shopping agents browse, add to cart, apply discounts, and check out across any Shopify store using a shared protocol. It bundles the Catalog Sync, Universal Cart, Discount API, and a Storefront MCP server hosted by Shopify. Merchants do not install an app. US merchants were auto-enrolled from March 24, 2026. See my Agentic Storefronts guide.

Universal Commerce Protocol (UCP) is the open specification underlying Agentic Storefronts. It defines how an AI agent discovers products, queries inventory, builds a cart across multiple merchants, applies discounts, and submits payment intent. UCP is what lets a single ChatGPT conversation buy a shirt from Store A and shoes from Store B in one checkout. The April 2026 update aligned Shopify's MCP server with UCP v1.

The April 2026 Agentic Storefronts update made three things production-ready: the Storefront MCP server (now hosted by Shopify, no merchant install), Universal Cart (multi-merchant checkout in a single agent session), and the Discount API for agent-applied codes. It also formalised Catalog Sync as the canonical product feed for AI engines. Read the April 2026 update breakdown.

Engines weight signals in roughly this order: structured data completeness (Product schema with price, availability, GTIN, brand), review count and average rating, content depth on the PDP, freshness of stock data, brand authority signals, and price competitiveness. ChatGPT and Perplexity also favour stores with clean Catalog Sync feeds because extraction is faster. A store with 50 verified reviews, full schema, and accurate inventory beats a store with vague descriptions and missing GTINs.

Four types matter most: Product (name, image, description, sku, gtin13, brand, offers), Review and AggregateRating, FAQPage, and BreadcrumbList. Add Organization schema sitewide for brand entity recognition. Validate with Google's Rich Results Test. On Shopify, most themes ship partial Product schema; audit yours and patch missing fields, especially gtin13 and priceValidUntil.

Catalog Sync is the canonical product feed Shopify pushes to AI engines under Agentic Storefronts. It includes title, description, variants, price, inventory, images, and metafields you flag as agent-visible. It updates in near real-time, so an agent never recommends an out-of-stock SKU. Configure it in Settings > Sales channels > Agentic Storefronts. Catalog Sync replaces the need to scrape your storefront.

If you are a US-based Shopify merchant on Basic plan or above, yes, from March 24, 2026. International merchants are being phased in through Q3 and Q4 2026. Check Settings > Sales channels for Agentic Storefronts. You can opt out per-channel or per-product. Most merchants should stay enrolled; opt-outs simply remove you from AI recommendations without any upside.

Add custom referral filters in GA4 Admin > Data streams > Configure tag settings, then build an Exploration segmenting Source by chatgpt.com, perplexity.ai, copilot.microsoft.com, gemini.google.com, and bing.com/chat. Add a custom channel group called AI Engines so it appears in standard reports. Volumes are still small but growth rate is the metric to watch.

Not soon, but it will redistribute traffic. Top-of-funnel research queries are migrating to AI fastest; transactional queries are stickier on Google for now. Realistic 2026-2027 picture: 15-25% of product discovery happens in AI engines, 60-70% on Google, the rest on social and direct. The smart move is GEO-and-SEO, not GEO-or-SEO, because the same fundamentals (clean schema, deep content, real reviews) win both.

Declarative, specific, and factual. AI engines extract sentences they can drop into an answer with high confidence. "The Acme X9 mattress is 25cm thick, made from CertiPUR memory foam, and ships free in the UK in 2-3 days" gets cited. "Experience the comfort of our premium sleep solution" does not. Use comparison tables, numbered specs, FAQ blocks, and clear pros/cons.

Faster than SEO. Schema and feed fixes can show within 2-4 weeks because AI engines re-crawl Catalog Sync and JSON-LD frequently. Content depth and review accumulation take 8-12 weeks to compound. Brand entity authority is the slowest lever, 6-12 months. A typical Shopify store doing GEO properly sees first AI referral traffic in GA4 within 30 days and meaningful volume by month 3.

No. GEO on Shopify is configuration, not installation. You need clean Product schema, accurate inventory, complete metafields, real reviews via any major app (Judge.me, Loox, Yotpo all work), and Agentic Storefronts enabled in Settings. Apps that promise "AI SEO" or "ChatGPT optimisation" are mostly schema validators wrapped in marketing. Spend the budget on a 2-3 hour audit instead.