How to monitor a Shopify store: what to watch, how often, and what to do when it turns

Shopify is remarkably good at running Shopify. Checkout, servers, databases, the whole plumbing, it stays up with a reliability most small teams could never build themselves. It is easy to conclude from this that monitoring is someone else's job. It is, for the platform. Cassian™ exists for the other half: your theme, your apps, your prices, your stock, and the particular way your checkout is configured, none of which Shopify is watching on your behalf and all of which can break while the platform itself reports perfectly healthy. This post is about what to watch, how often, and what good looks like, not about which tool to buy.

Start with platform status, every time something looks wrong

Before you touch your theme code or start refunding confused customers, check whether Shopify itself is having a bad day. Shopify's status page reports per component: Admin, Checkout, Online Storefront, Shop Pay, Retail POS, and the various APIs. You can subscribe by email or SMS and get notified the moment something shifts.

This should be the first thing you check whenever a customer says checkout is broken or your dashboard looks odd. It takes thirty seconds and it is authoritative: if Shopify says checkout is degraded, you can stop debugging your app stack and just wait it out. If Shopify says everything is green, you know the problem is yours, and you can move on to the sections below.

This is also, worth saying plainly, the one job Cassian does not do. Platform status is Shopify's own signal to give, and it does it well. Everything downstream of a healthy platform, meaning your specific store, is where the rest of this list matters.

Reachability: necessary, not sufficient

Is your storefront responding at all? This is the most basic health check there is, and free tools like UptimeRobot do it well, pinging your homepage every few minutes and alerting when it stops responding.

The important caveat, worth stating once and remembering permanently: a broken store usually still returns a normal HTTP 200 response. A theme error that hides your add-to-cart button, a checkout step that silently fails, an app conflict that breaks the cart drawer, none of these make your server return an error code. The page loads. It just doesn't sell anything. So treat reachability as a floor, the thing that tells you the lights are on, not a ceiling that tells you business is being conducted normally.

Cassian runs uptime checks as part of its paid tiers, alongside the signals below that actually catch the failures reachability misses.

Order flow: the signal that catches almost everything else

If you watch one thing, watch orders. Nearly every failure that matters, a broken checkout, a payment gateway outage, a theme bug that hides the buy button, a pricing error that drives customers away, eventually shows up as orders stopping. This makes order flow the highest-leverage signal on this whole list: you don't need to separately monitor every possible cause when you're watching the shared symptom.

The hard part is knowing what normal looks like, and this is where a lot of DIY monitoring goes wrong. Order volume varies enormously by hour and by day of week. A fixed rule like "alert me if there are no orders in three hours" either fires constantly overnight, when three quiet hours is simply Tuesday at 4am, or it never fires at all if you set the threshold loose enough to survive the overnight lull. Neither is useful.

The useful comparison is against the store's own pattern: what does a Tuesday morning normally look like for this particular store, and does today's Tuesday morning look like that. Three hours with no orders on a Tuesday morning is worth a look. The same three hours at 4am is nothing. This is exactly what Cassian's Order Pulse watches, comparing current order flow against your store's own history rather than against a number someone guessed. If your store stops taking orders and it isn't 4am, you want to know within minutes, not when you happen to check your dashboard that evening. For a deeper look at diagnosing a sales drop once you've noticed one, see the 48-hour checklist for a sudden drop in sales.

Checkout: test it right after anything changes

Theme publishes and app installs are the leading cause of a broken checkout funnel, and they tend to break things quietly. A new app writes a script that conflicts with your theme's cart drawer. A theme update reorders checkout fields in a way that hides the shipping selector on mobile. Nobody notices until someone asks why orders dried up.

The practical habit is to treat a theme publish or a meaningful app change the way a developer treats a deploy: test add-to-cart and a full checkout run-through immediately afterward, on both desktop and mobile. It takes a few minutes and it catches the obvious breaks before a customer does. Why Shopify stores lose orders during theme updates goes into the specific ways this tends to happen.

For stores where an hour of broken checkout is genuinely expensive, scripted synthetic tests that click through your funnel on a schedule are worth setting up. Checkly is built for exactly this kind of end-to-end monitoring. It is a heavier setup than a basic uptime check, which is the right tradeoff for a store where checkout failing during a busy hour is a meaningful loss, and the wrong one for a smaller store where checking manually after changes is enough.

Prices and stock: cheap to check, expensive to ignore

A price error rarely announces itself. Variants priced at ten cents sell briskly. Nobody files a support ticket to say your product is too cheap. The moment to check prices is right after anything that touches them in bulk: a mass edit, a discount campaign going live or ending, or an app that writes prices programmatically. A five-minute spot check after any of these catches the kind of error that otherwise surfaces days later in your margin report.

Stock deserves the same attention, especially on top sellers during a promotion you're paying to drive traffic to. Running an ad campaign to a product that quietly sold out an hour into the sale is an expensive way to learn about your inventory sync.

Cassian watches both continuously through Pricing Pulse and stock-out and low-stock alerts, catching the ten-cent variant or the sold-out bestseller before it costs you a day's traffic budget.

Speed, links, and search health

These move more slowly than orders or prices, which makes it tempting to ignore them until traffic drops and you're left reconstructing what happened. Shopify's own Web Performance report is genuinely useful here: it shows Core Web Vitals from real visitor data and marks app installs and theme changes directly on the timeline, which makes it good at explaining a speed drop after the fact, even if it won't alert you proactively.

Google PageSpeed Insights and Search Console round out the free toolkit, the former for a quick performance snapshot, the latter for how Google actually sees your site. Per web.dev's guidance, the thresholds worth knowing are Largest Contentful Paint under 2.5 seconds, Interaction to Next Paint under 200 milliseconds, and Cumulative Layout Shift under 0.1. Checking monthly is enough, plus a look after any app install, since third-party scripts are a common cause of regressions.

Worth watching alongside speed: broken links, whether your sitemap is current and reachable (see how to tell if your sitemap is quietly broken), and increasingly, whether your product feed and structured data are readable by AI shopping agents, a newer concern covered in is your store saying the right thing to AI shopping agents. Cassian checks all of these on a schedule and alerts on the drop, so you find out from a notification rather than from a slow, unexplained traffic decline. If you're trying to figure out whether a drop you've already noticed is your fault or Google's, this piece walks through the diagnosis.

Know what changed

Theme publishes, app installs, and app updates are the events that precede most breakage. This isn't a coincidence, it's just how software works: a store that isn't touched doesn't spontaneously stop selling, but a store that just got a new app or a fresh theme version has a new opportunity to conflict with something.

The practical discipline isn't complicated. Know when a change happened. Keep a rough log, even a mental one, of the last theme publish and the last few app installs. When something turns, the first question is always "what changed," and having the answer already saves you the hour you'd otherwise spend guessing.

A short note on cadence

None of this needs to be a full-time job. A glance at order flow takes a few seconds and is worth doing daily. A weekly pass on broken links and page speed takes a few minutes. A deeper monthly look, covering Core Web Vitals trends, Search Console, and a stock and pricing spot-check, rounds it out. The goal is a habit light enough that you'll actually keep it, not a checklist so long it gets skipped.

Where Cassian fits

Every tool mentioned above is genuinely good at what it does, and every one of them shares the same limitation: it reports when you visit it. You have to remember to check the status page, open the uptime dashboard, run PageSpeed Insights, log into Search Console. That's fine for a monthly review. It's a gap for the failures that cost you money by the hour.

Cassian is built around the alternative: watch continuously, and push the alert to you rather than waiting for you to come looking. It covers order flow through Order Pulse, pricing errors through Pricing Pulse, stock-outs and low stock, uptime on paid tiers, page speed, broken links, sitemap health, SEO health, translation accuracy for multilingual stores, AI product feed quality, and security scanning through Cassian Shield™. All of it rolls up into the Cassian Score™, a 0-100 summary of overall store health, though the alerts are the actual product; the score is just a fast way to see where you stand. Cassian for Shopify runs alongside WooCommerce and BigCommerce stores as well, so the same coverage applies whichever platform you're on. Cassian doesn't replace the judgment in this post, and it won't catch everything. It's the difference between checking for a problem and being told about one.

The short version

Shopify handles the infrastructure. You, or something watching on your behalf, need to handle the rest: whether orders are still flowing, whether checkout still works after the last change, whether prices and stock look right, and whether search and speed are holding up. Check platform status first when something looks wrong, watch order flow above everything else, and test checkout right after any theme or app change. Cassian exists to do that watching continuously, so the alert reaches you before a customer has to tell you something's off.