Shopify Performance Monitoring: Tools and Alerting Setup

Your Shopify store is down. Customers see a 502 error. Your Slack blows up. By the time you notice, you've lost $5K in sales.

Performance monitoring isn't optional at scale. According to Forrester's 2024 Performance Engineering Report, every minute of downtime costs mid-market e-commerce merchants $500–$2,000. For Shopify Plus merchants doing $100M+ annually, that's $8K–$33K per minute.

This guide covers the tools and setup that enterprise Shopify merchants use to catch performance degradation before customers notice.

The Three Layers of Monitoring

Layer 1: Uptime Monitoring

Is your store accessible? These tools ping your storefront every 30 seconds and alert if it's down.

Layer 2: Performance Monitoring

How fast is it? Core Web Vitals (LCP, FID, CLS), page load time, API latency. A slow store converts 7–10% worse than a fast one (source: Baymard Institute, 2024).

Layer 3: Business Monitoring

Is revenue flowing? These tools track checkout success rate, payment gateway latency, and order processing.

Tool Stack

1. Uptime Monitoring — Uptime.com or Betterstack

Uptime.com

• Ping your store every 30–60 seconds from 210+ global locations
• SSL certificate expiry alerts
• Slack/PagerDuty integration
• Cost: $9/month (Basic) → $99/month (Pro)

Betterstack

• Same features as Uptime.com, simpler UX
• Custom webhooks (send alerts to your own service)
• Cost: $12/month → $119/month

Setup

1. Create an account at uptime.com or betterstack.com
2. Add your store URL: https://mystore.myshopify.com
3. Set check frequency: 30 seconds (every 2 minutes is too slow)
4. Add Slack webhook:
   • Go to your Slack workspace → Settings → Apps → Incoming Webhooks
   • Create a new webhook for #ops-alerts
   • Paste the webhook URL into Uptime.com
5. Set alert threshold: 2 consecutive failed checks = alert (avoids false positives)

Cost for Shopify Plus merchant

$50–$100/month. Worth it. One incident prevented saves the cost 10x.

2. Performance Monitoring — Lighthouse CI

What it does

Lighthouse is Google's open-source performance auditor. Lighthouse CI integrates with your deployment pipeline and fails builds if performance degrades.

Example: Your developer merges code that adds 200KB of JavaScript. Lighthouse CI measures LCP (Largest Contentful Paint). If LCP goes from 1.8s to 2.4s, the build fails. No deployment. No performance regression.

Setup (GitHub + Shopify Theme)

Assuming you're using GitHub to version control your Shopify theme:

1. Install Lighthouse CI:

npm install -g @lhci/cli@latest

2. Create .github/workflows/lighthouse.yml:

name: Lighthouse CI
on: [push, pull_request]
jobs:
  lhci:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: 18
      - run: npm install -g @lhci/cli@latest
      - run: lhci autorun

3. Create lighthouserc.json in repo root:

{
  "ci": {
    "collect": {
      "url": ["https://mystore.myshopify.com/", "https://mystore.myshopify.com/products/example"],
      "numberOfRuns": 3,
      "settings": {
        "chromeFlags": "--no-sandbox --disable-dev-shm-usage"
      }
    },
    "upload": {
      "target": "temporary-public-storage"
    },
    "assert": {
      "preset": "lighthouse:recommended",
      "assertions": {
        "first-contentful-paint": ["error", { "maxNumericValue": 3000 }],
        "largest-contentful-paint": ["error", { "maxNumericValue": 4000 }],
        "cumulative-layout-shift": ["error", { "maxNumericValue": 0.1 }],
        "speed-index": ["error", { "maxNumericValue": 5000 }]
      }
    }
  }
}

This config:

• Audits your home page and a sample product page
• Runs each audit 3 times (for stable results)
• Fails the build if LCP > 4s, FCP > 3s, CLS > 0.1, or Speed Index > 5s

Cost

Free (open-source). Host on GitHub Actions (free for public repos, $0.008/min for private).

3. Real User Monitoring (RUM) — Sentry or LogRocket

Sentry

Captures JavaScript errors in real time. If a customer gets an error on checkout, Sentry logs it with session replay, so you can see exactly what happened.

Setup

1. Create a Sentry account (free tier for startups)
2. Create a new project for your Shopify store
3. Copy your Sentry DSN (Data Source Name)
4. Add to your Shopify theme's theme.liquid:

<script
  src="https://browser.sentry-cdn.com/7.80.0/bundle.min.js"
  integrity="sha384-..." crossorigin="anonymous"></script>
<script>
  Sentry.init({
    dsn: "https://[email protected]/0",
    tracesSampleRate: 0.1,
  });
</script>

5. Enable Session Replay in Sentry (captures user interactions leading to errors)

Cost

Free tier (5K errors/month) → $99/month for 50K errors/month

4. API & Checkout Monitoring — Custom Webhooks

Monitor the critical path: order creation, payment processing, inventory sync.

Setup

Use Shopify Webhooks + a monitoring service:

1. Go to Shopify Admin → Settings → Notifications → Webhooks
2. Create webhooks for:
   • orders/created
   • orders/paid
   • orders/fulfilled
3. Send webhook payloads to a monitoring endpoint you control (or third-party service like Webhook.cool)
4. Log every webhook with timestamp and success status
5. Alert if webhooks fail or are delayed

Example: Monitor Order Success Rate

# Monitor orders/created webhook
import time
from datetime import datetime, timedelta

# Every 5 minutes, check order creation rate
def check_order_rate():
    orders_last_5min = db.query("SELECT COUNT(*) FROM orders WHERE created_at > NOW() - INTERVAL 5 MINUTE")
    orders_avg = 10  # Your baseline
    
    if orders_last_5min < orders_avg * 0.5:  # 50% drop
        alert("Order creation rate down: {} orders in last 5min (avg: {})".format(orders_last_5min, orders_avg))

Alert Strategy: What to Monitor

Critical Alerts (Page oncall immediately)

• Store uptime < 99.9% (outage)
• Checkout page LCP > 5s (losing revenue)
• Payment gateway latency > 10s (orders not completing)
• Order creation webhooks failing (inventory/fulfillment at risk)
• Cart abandonment spike (metric up 30%+ from baseline)

Warning Alerts (Slack, review in morning)

• Core Web Vitals degradation (LCP from 2s → 3s)
• 502 error rate > 1%
• JavaScript error rate > 0.5%
• API response time > 2s (background task, not checkout)

Informational (Logs only)

• Deployments (record when code shipped)
• Performance metrics above baseline but below warning threshold

Tenten's Monitoring Stack for Enterprise Clients

Tenten manages performance monitoring for 15+ Shopify Plus merchants. Our standard setup:

• Uptime: Betterstack ($15/month)
• Performance: Lighthouse CI + GitHub Actions (free)
• RUM: Sentry Pro ($99/month)
• Custom: Order/checkout monitoring (hosted on AWS Lambda, ~$50/month)
• Alerting: PagerDuty for critical, Slack for warnings ($30/month)

Total cost: ~$200/month. Prevents one incident per quarter on average. ROI: 50x.

Implementation Checklist

• [ ] Set up uptime monitoring (Uptime.com or Betterstack) with Slack alerts
• [ ] Install Lighthouse CI in your GitHub CI/CD pipeline
• [ ] Configure Core Web Vitals alerts (LCP, FID, CLS thresholds)
• [ ] Enable Sentry in your theme for error tracking + session replay
• [ ] Create webhook monitors for critical orders/payments flows
• [ ] Set up alert routing (critical → oncall, warnings → Slack)
• [ ] Document runbooks for each alert (what to do when it fires)
• [ ] Test failover (simulate an outage, verify alerts work)
• [ ] Review dashboards weekly (are your baselines accurate?)

---

Ready to Implement Enterprise-Grade Monitoring?

Setting up comprehensive monitoring requires understanding Shopify's infrastructure, Lighthouse metrics, alerting architecture, and incident response workflows. Tenten specializes in building monitoring stacks for Shopify Plus merchants. We can audit your current setup, recommend tools, and implement alerts that prevent revenue loss.

Contact Tenten for a monitoring strategy consultation at tenten.co/contact.

---

Editorial Note

This guide draws on Tenten's deployment of monitoring infrastructure for Shopify Plus partners. Data sourced from Forrester Performance Engineering Report 2024, Baymard Institute checkout studies, and Google Lighthouse documentation (2026).