Your store is online. Can anyone actually buy?
Buying is a chain of public pages, and revenue needs every link in it. A real browser checks each one every 15 minutes, from product page to checkout entry, and tells you the moment one of them stops selling.
Uptime answers a question nobody is asking.
A monitor confirms your server is willing to talk. It has no opinion about whether the page it returned can still take an order.
- Can a customer add this to their cart?The server responded.
- Does the cart still lead to checkout?The server responded.
- Can anyone reach checkout?The server responded.
One broken link does not reduce sales. It stops them.
Every purchase walks the same path. Break any single step and the whole thing pays nothing, while each page in it keeps reporting that it is perfectly fine.
Select any link in the path. Every one of them returns 200 OK while it is broken.
They found the thing they wanted, and there is no way to begin buying it.
- The price stops rendering
- Add-to-cart renders disabled
- The variant selector never populates
- Critical Content
- Key Action
Checked against production in a real browser, on the rendered page a customer would get.
Checkout entry, not payment.
KeyPages protects the path a customer walks toward paying: the product page sells, the cart leads on, the checkout page opens and its provider loads. It stops at the door. It does not submit forms, create accounts, place orders, or submit payments, and no card details are ever entered or stored.
- Checked, every 15 minutes
- Add-to-cart present and enabled
- Cart shows contents and a live checkout button
- Checkout route reachable, not redirected away
- Checkout provider script and frame load
- Never done
- Adding an item to a real cart
- Entering address or card details
- Placing a test order
- Anything behind a customer login
A silent failure is the expensive kind.
Ads keep spending, email keeps sending, and search keeps delivering people to a page that can no longer sell.
The status page stays green, the deploy looked clean, and the dashboard shows a page that is being served.
If they bother to tell you. Detection time is however long it takes someone to complain.
An outage is loud, so it gets fixed fast. A page that loads and cannot sell can run for hours, because nothing in your stack considers it a problem.
Every commerce page has one job.
KeyPages works out what kind of page you gave it, then checks that the control the page exists for is present and usable. Checks that do not apply to a page stay off, and are never counted as a pass.
- ProductAdd-to-cart present and enabled
- CollectionProducts listed, links reach them
- CartCheckout button present
- Checkout entryReachable, provider loads
Most store breaks are not deploys.
Themes update themselves, apps push new scripts, and providers move domains. None of it goes through your release process, so nothing in it can catch the result. The next 15-minute check does.
- A theme update shipsThe add-to-cart button is still in the HTML, but a new stylesheet renders it disabled.
- An app is installed or updatedIts script fails to load, and the cart page renders without a checkout button.
- A checkout script domain changesThe page looks fine, but the domains it expects to load are no longer the ones it does.
The two places revenue leaks quietest.
Product pages rarely go down. They lose the price, the buy button, or the structured data that earns the click.
Read moreCheckout pathThe only clicks that payCheckout breaks at boundaries you do not deploy, which is exactly why your release process cannot catch it.
Read moreStart with one page. The one that takes the money.
Paste the live URL. KeyPages works out what it is and what it has to do.