The short version: You paste a store domain. We check it every 5–15 minutes by making the same HTTP requests a real visitor would make. We alert you the moment something changes — checkout goes down, the theme changes, speed tanks, SSL expires. One alert when it breaks. One when it recovers. No noise.
Paste a Shopify domain — yourstore.myshopify.com or a custom domain like
yourstore.com. That's it. We don't need your Shopify credentials, we don't install an app
on the store, and your client never needs to know a monitoring tool has been set up.
We resolve the domain to its canonical Shopify storefront URL on the first check, following any redirects
so monitoring stays accurate even if a store switches from a .myshopify.com URL to a custom
domain.
Agency note: You're responsible for ensuring you have the right to monitor stores you add. See our Terms of Service for the full picture — the short version is that you should own the store or have your client's authorisation.
After the first three successful checks we establish baselines for speed scoring and structural hashing. From that point on, you're fully monitored.
Every check runs the same sequence of steps for each store. On your plan's interval — every 5 minutes on Pro and Agency, every 15 minutes on Free.
We make a standard HTTP GET to the store's homepage, following redirects. We record the HTTP
status code, response time in milliseconds, and the final landed URL. Our bot identifies
itself as RadarMonitorBot/1.0.
We parse the returned HTML to detect password protection, compute a structural hash of the DOM, extract the active theme name, and calculate a speed score from response time and page weight.
Separately, we hit /products.json to find a real product, then POST to /cart/add.js
with a valid variant ID. This confirms checkout infrastructure is actually working — not
just that the storefront loaded.
We verify the TLS certificate is valid and check when it expires. Alerts fire at 14 days and again at 3 days before expiry.
We compare this check's results against the stored summary. Events only fire when state changes — not on every check. Store went from healthy to unreachable? Event fires. Still unreachable? Silence.
Every check result is saved as a snapshot for your history view. The store's summary record is updated with the latest health status, active issues, and detected state.
This is the part most monitoring tools skip. A generic uptime checker confirms the storefront returned HTTP 200. That's not enough — a store can load fine while its checkout is completely broken.
We probe checkout in three steps:
GET /products.json?limit=1 — Shopify's public storefront API. We pull the first
available product and extract a purchasable variant ID.
POST to /cart/add.js with that variant ID and quantity 1. This is the same call
the storefront makes when a customer clicks "Add to Cart". A 200 response means checkout
infrastructure is operational.
We interpret the response code carefully. A 200 means the item was added
successfully. A 422 also counts as available — it means the cart
API is alive and responding correctly, but the specific item has an item-level problem (sold
out, invalid variant, etc.). The checkout infrastructure is working; that's what we care
about. A 5xx means checkout infrastructure is broken. A 401 or
403 means the store is password protected. If products.json
returns no products we mark the result as unknown — we can't probe, but that doesn't mean
checkout is broken.
Does this create fake orders? No. Adding to cart does not create an order or a checkout session. It writes a temporary server-side cart entry that expires. There is no order, no inventory reservation, no customer record, and nothing visible in the Shopify admin. It's equivalent to a real customer adding something to their cart and closing the tab.
Every check generates a structural hash of the storefront — a SHA-256 fingerprint of the page's layout, sections, installed apps, and tracking pixels. When the hash changes, something meaningful changed about the store.
We deliberately include signals that matter for store health and exclude signals that create noise:
| Signal | Included? | Why |
|---|---|---|
Shopify section IDs (data-section-id) |
Yes | Theme section changes mean layout changed |
Theme name (window.Shopify.theme.name) |
Yes | Direct signal of a theme switch |
| Theme CSS asset filename | Yes | Catches theme version bumps |
| Cart form & checkout link presence | Yes | Disappearing = broken layout |
| Installed apps (Klaviyo, Gorgias, Yotpo, ReCharge, etc.) | Yes | App installs/removals are structural changes |
| Tracking pixels (GA4, Meta, TikTok, Pinterest, Snapchat) | Yes | Pixel going missing is a real problem |
| Body CSS classes | Yes | Template-level changes |
| Product prices, descriptions, inventory | No | Content changes, not structure — would fire constantly |
| CSS query string version numbers | No | Stripped — cache-busting params aren't structural |
| Dynamic content (countdown timers, personalisation) | No | Would create false positives on every check |
A naive hash comparison would fire alerts for every A/B test. We use a stability window: a new hash must appear on two consecutive checks before we treat it as a genuine change and fire a STOREFRONT CHANGED event. A hash that appears once and then reverts is silently discarded as a transient variation.
At 5-minute check intervals, this means a theme change is confirmed in around 10 minutes. At 15-minute intervals it's around 30 minutes — a trade-off of speed versus noise on the Free plan.
Raw response times are noisy — network conditions vary, servers have spikes, CDNs have bad days. We use a relative baseline approach so alerts fire on meaningful degradation, not momentary blips.
The first three successful checks with valid response times are averaged to form the store's speed baseline. This baseline is stored and updated only by adding new successful checks into a rolling average — it won't drift from a single slow check.
We convert response time to a 0–100 score on a Lighthouse-style curve. Faster stores score higher. The exact score matters less than the change in score.
A SPEED DEGRADED alert fires when the current speed score drops 40 or more points below the baseline. Examples:
| Baseline score | Current score | Drop | Alert? |
|---|---|---|---|
| 85 | 40 | 45 pts | Yes — 45 ≥ 40 |
| 85 | 60 | 25 pts | No — 25 < 40 |
| 30 | 50 | — | No — improved |
| 30 | 0 | 30 pts | No — 30 < 40 |
The relative threshold means a naturally slow store (baseline 30) won't spam alerts just because it's slow. And a fast store (baseline 90) gets alerted when it drops to 50, which would be invisible to an absolute threshold set at "alert below 40."
Speed alerts are suppressed when the store is unreachable. An unreachable store already has a STORE UNREACHABLE alert open. We don't pile on with a speed alert for the same underlying problem.
We check the TLS certificate on every monitoring cycle. We verify it's currently valid and read its expiry date. Two alerts are generated automatically:
An expired certificate puts a red padlock warning in every visitor's browser. For a client's store, this is often a more urgent problem than downtime — it actively destroys conversion.
We detect password-protected stores by checking for Shopify's password template signals — the template-password
body class, /password form actions, and related DOM markers. When detected:
Agencies accidentally putting client stores into password mode (during theme work, for instance) is a surprisingly common and embarrassing incident. This catches it in the next check cycle.
The most important design decision in Radar Monitor is that alerts only fire on state transitions — not on every failed check. If a store is down for an hour, you get one alert when it goes down and one when it recovers. Not 12 alerts in the meantime.
A single failed check doesn't trigger an alert. We require two consecutive failures before firing a STORE UNREACHABLE event. This eliminates false alarms from transient network conditions, CDN hiccups, and our own infrastructure variability.
On a 5-minute check interval, this means you might not hear about a genuine outage for up to 10 minutes after it starts. On the Free plan's 15-minute interval, that extends to up to 30 minutes. That's the deliberate trade-off for eliminating false positives. One false alarm at 3am trains teams to ignore future alerts. We'd rather be slightly slower and always trustworthy.
Here are real examples of what arrives in your inbox:
↑ Outage alert. Sent once on first confirmed failure.
↑ Recovery alert. Sent on first successful check after outage.
| Event | Severity | Trigger |
|---|---|---|
| Store unreachable | Critical | 2 consecutive failed HTTP requests |
| Store recovered | Info | First successful check after unreachable |
| Checkout unavailable | Critical | Cart probe returns 5xx (422 = available, infrastructure is responding) |
| Checkout restored | Info | First successful cart probe after failure |
| Storefront changed | Warning | Structural hash stable across 2 consecutive checks |
| Speed degraded | Warning | Speed score drops ≥ 40 points below baseline |
| Password protected | Warning | Password template detected (state change) |
| SSL expiring soon | Warning | Certificate expires in ≤ 14 days |
| SSL expiring critical | Critical | Certificate expires in ≤ 3 days |
robots.txt. If a store's robots.txt
disallows RadarMonitorBot, we stop monitoring it and notify the account holder. See our
bot transparency page.
From a technical standpoint, no — we access only public storefront URLs, the same ones any visitor hits. From a relationship standpoint, we'd recommend disclosing it as part of your agency's standard monitoring practices. Our Terms of Service require that you have the right to monitor any store you add.
Potentially in server logs, yes. In GA4 or other analytics tools that filter bots, no — our user
agent RadarMonitorBot/1.0 will be filtered by most analytics platforms automatically.
If your client uses raw log analysis, they may see our requests, which is why we publish a bot transparency page explaining exactly what we do.
Minimal. Each 5-minute check cycle makes 2–3 HTTP requests: one to the homepage, one to /products.json,
and one POST to /cart/add.js. At 5-minute intervals that's roughly 864 requests per day
— comparable to a handful of real visitors. Shopify's infrastructure handles many orders of
magnitude more than this routinely.
If a store's robots.txt disallows RadarMonitorBot, we stop making requests
and send you a notification that the store is blocking our bot. Your account still exists and the
store remains in your dashboard — monitoring is just paused until the robots.txt rule is removed, or
you remove the store.
We can detect that a store is password protected, which itself is a monitored state. We cannot probe behind the password page. If a store you're monitoring gets put into password mode, you'll get an alert — which is often the most useful signal (accidental password protection is a common agency mistake during theme work).
Order Heartbeat monitors actual order volume via Shopify's admin API and alerts you when orders stop flowing even though the storefront looks healthy. This requires connecting the store via OAuth (a Shopify app install). It's a more powerful signal than checkout probing alone — a checkout can return 200 while something upstream silently breaks real transactions. This feature launches in Month 8 of our roadmap and requires a Pro or Agency plan.
The monitoring logic is identical across all plans. The differences are check frequency, number of stores, history retention, and alert channels:
| Plan | Stores | Interval | History | Alerts |
|---|---|---|---|---|
| Starter | 3 | 15 min | 7 days | |
| Pro | 20 | 5 min | 30 days | Email + Slack |
| Agency | Unlimited | 5 min | 6 months | All channels |
All plans are free during early access. See full pricing →
We're building this in public and talking directly to agencies. If something here is unclear or you want to know how we'd handle a specific scenario, we'd love to hear from you.