The Scenario
It's 2 AM. Your team pushes a CSS update. The deployment succeeds. CI/CD is green. Your uptime monitor pings your homepage, gets a 200 OK, and happily reports everything is fine.
Six hours later, your support inbox explodes. Customers are sending screenshots of your checkout page. The buy button is invisible. Product images are gone. The navigation is stacked vertically, covering the entire viewport. Your site has been broken for six hours, and not a single alert fired.
The uncomfortable truth
Every major website has experienced this. An HTTP 200 response means your server responded. It says nothing about whether the page your customer sees actually works.
This isn't a theoretical edge case. It's the most common blind spot in website monitoring. And it's exactly what visual regression testing was built to solve.
Why HTTP 200 Doesn't Mean “Working”
Traditional uptime monitors work like this: they send an HTTP request to your URL, check that the server responds with a status code in the 200 range, and maybe verify that the response time is acceptable. That's it. They never open a browser. They never render CSS. They never execute JavaScript.
Think of it like calling a restaurant to check if they're open. Someone answers the phone and says “yes.” You assume everything is fine. But when you arrive, the kitchen is on fire, there are no tables, and the menu is in the wrong language. The phone was answered — that's your 200 OK. The actual experience is something else entirely.
What uptime monitors check
- TCP connection established
- HTTP status code is 200
- Response time under threshold
- Does NOT render the page
- Does NOT execute JavaScript
- Does NOT load CSS or images
What users experience
- •Fully rendered page with CSS
- •Images loaded from CDN
- •JavaScript executed and interactive
- •Fonts loaded and displayed
- •Third-party widgets and embeds
- •Correct layout and visual design
The gap between these two views is massive. Your server can return a perfectly valid HTTP response containing completely broken HTML and CSS. A 200 just means “the server processed the request successfully.” It says nothing about the quality, correctness, or visual integrity of the response.
If you're relying only on tools like UptimeRobot for monitoring, you're leaving the entire visual layer unchecked.
Real Examples of “Up But Broken”
These aren't hypothetical scenarios. They happen to teams of every size, every week. In each case, the uptime monitor reports 200 OK. In each case, the site is broken for real users.
Missing Images
Your CDN token expires at midnight. Every product image across your entire e-commerce site starts showing the browser's broken image icon. The HTML is served correctly. The server responds with 200. Your uptime monitor sees a healthy site.
Meanwhile, your customers see a catalog full of grey placeholder boxes. Conversions drop to near zero, but your monitoring dashboard shows 100% uptime.
Broken Layouts
A CSS file fails to load — maybe a deployment artifact was missed, maybe the CDN purged it, maybe a build step silently failed. Your entire site renders as unstyled HTML. Raw text, no spacing, no colors, no grid. The 1998 look.
The server sent back a valid HTML response. Status code: 200. Your monitor doesn't know that the stylesheet returned a 404 because it never tried to load it. It never rendered the page at all.
JavaScript Errors
Your React app hits an unhandled exception. The error boundary catches it and renders... nothing. A white screen. Or maybe just the header with an empty body. The server returned the HTML shell with all the <script> tags intact. Status: 200. The JavaScript just crashed on execution.
This is especially common with SPAs (Single Page Applications) where the server delivers a minimal HTML document and JavaScript builds the entire UI. If the JS fails, the page is a blank canvas.
Wrong Content Served
A caching misconfiguration causes your CDN to serve the homepage on every URL. Users visit your pricing page — they get the homepage. They visit your documentation — homepage again. Every request returns 200 OK with perfectly valid HTML. It's just the wrong HTML.
Traditional monitors would need keyword checks on every single page to catch this. Visual monitoring catches it instantly because the page looks different from the baseline.
Font CDN Down
Google Fonts or your custom font CDN has an outage. Your site renders in Times New Roman or the system's default sans-serif. The layout shifts subtly as the fallback font has different metrics. Buttons overflow. Headlines wrap in unexpected places.
The site is technically operational. But it looks unprofessional and unfamiliar to your users. Your brand feels off. An uptime monitor has no concept of what font a page is supposed to use.
What Is Visual Regression Testing?
Visual regression testing is the automated comparison of screenshots against a known-good baseline to detect unintended visual changes. Instead of checking status codes or parsing HTML, it looks at what the page actually looks like — the way a human would.
How it works
Development vs Production
There are two distinct approaches to visual testing, and understanding the difference matters:
- Code-based tools (Playwright, Cypress, Percy): These run during your CI/CD pipeline. You write test scripts that capture screenshots at specific points in your test flow. They catch regressions before deployment. They require developer involvement to write and maintain tests.
- Visual monitoring tools (like Visual Sentinel): These run continuously on your production site. No code required. They automatically establish baselines and check your live pages on a schedule. They catch issues that CI/CD tests can't: CDN failures, third-party outages, caching bugs, and deployment misconfigurations.
Both approaches are valuable. CI/CD visual tests prevent you from shipping broken code. Production visual monitoring catches everything else — the things you couldn't predict.
Visual Monitoring vs Playwright Testing
If you're already using Checkly or Playwright for synthetic monitoring, you might wonder: do I need visual monitoring too? The short answer is yes. They solve different problems.
| Feature | Playwright / Checkly | Visual Monitoring |
|---|---|---|
| Code required | Yes (JavaScript/TypeScript) | No |
| When it runs | During CI/CD or on schedule | Continuously on production |
| What it tests | Specific scripted flows | Any page, as users see it |
| Baseline setup | Manual snapshot updates | Automatic |
| Catches CDN failures | Only if explicitly tested | Yes, automatically |
| Catches caching bugs | Unlikely | Yes |
| Who can use it | Developers | Anyone on the team |
| Maintenance | Tests need updating with UI changes | Baselines update automatically |
They're complementary, not competing
Use Playwright in CI/CD to catch visual regressions before deployment. Use visual monitoring in production to catch everything else: CDN outages, third-party failures, caching issues, and the unexpected changes that no test suite anticipated. Together, they give you complete visual coverage.
For a deeper comparison with Checkly specifically, see our Visual Sentinel vs Checkly comparison.
How to Start Visual Monitoring
Setting up visual monitoring with Visual Sentinel takes about two minutes. No code, no browser extensions, no complex configuration.
Add your URL
Enter the page you want to monitor. Visual Sentinel opens it in a real Chromium browser and captures a baseline screenshot.
Configure sensitivity
Set how much visual change is acceptable before an alert triggers. This lets you ignore dynamic elements like ads or live data while catching real issues.
Get alerted
When a visual change exceeds your threshold, you receive an alert via email, Slack, Discord, Telegram, or WhatsApp with a side-by-side comparison.
Visual monitoring runs alongside uptime, performance, SSL, DNS, and content checks — all in one tool. You can try it right now with our free website checker to see what kind of issues it catches, or check our pricing plans starting at $5.40/month.
If you're already using an uptime monitor like UptimeRobot, visual monitoring fills exactly the gap described in this article. Your uptime tool checks that the server responds. Visual Sentinel checks that the response looks right.
Catch Visual Bugs Before Your Users Do
Stop relying on HTTP status codes alone. Visual Sentinel monitors what your site actually looks like, and alerts you the moment something changes.
Start Monitoring Free