One dashboard. Every way your site can fail.
Web QA OS is a single platform for uptime monitoring, browser QA journeys, real-browser performance testing, and load testing - the five subscriptions you're already paying for, replaced by one login and one bill.
Coming Soon - Reach Out for Early AccessYou're already buying this. Five separate times.
An uptime monitor. A synthetic test runner. A visual regression tool. A page-speed auditor. A load-testing platform. Five logins, five invoices, five dashboards that don't talk to each other - and not one of them tells you the whole story when something breaks.
Four engines. One evidence trail.
Watchtower
Uptime and health monitoring that checks the whole site, not just a status code.
Replaces a standalone uptime monitorDNS resolution, TLS expiry, HTTP-to-HTTPS redirect, status, response time, security headers, robots.txt, sitemap.xml, screenshots, browser console errors, broken links, broken assets, and metadata/content assertions - in one pass, not thirteen tools.
7/30/90-day uptime per site, computed from real check history, with per-site overrides on top of your default check configuration.
Every run captures a screenshot and full check breakdown. Export to HTML, PDF, Markdown, JSON, or ZIP - the report you actually hand to a client.
Flow Lab
Record real browser journeys, replay them on a schedule, and know the moment one breaks.
Replaces a synthetic E2E testing cloud and a visual regression toolClick and type in a real browser - in-app, streamed live, or locally via the wqa CLI - and get working steps back. A ranked selector strategy (data-testid, then ARIA role, then text, then stable id/name, then a positional fallback) picks a selector that survives a redesign, not one tied to a CSS class that changes next sprint.
Every recorded journey replays itself before anything gets inserted. Steps that don't resolve are reported with a reason, not silently dropped - so you know exactly what didn't make it and why, instead of finding out during a failed run three weeks later.
Feed a suite a CSV of rows and it runs the entire journey once per row - different logins, different form inputs, different search terms - with {{token}} substitution into paths, selectors, and assertions. One suite, dozens of real scenarios.
Any step can be a pixel-diff visual check against a stored baseline, with a configurable pass threshold and a red-highlighted diff image the moment something shifts.
Pull a value off the page into a variable mid-run, reuse it in later steps, and skip steps conditionally without failing the run - real branching logic, not a rigid linear script.
Speed Lab
Real browser performance, not a synthetic score guessed from a formula.
Replaces a page-speed tool and a standalone accessibility auditorMeasured live in a real Chromium instance via a PerformanceObserver, not estimated. Every metric is rated good / needs improvement / poor against Google's own Web Vitals thresholds.
Desktop, iPhone 13, Pixel 5, or iPad viewports; Regular 4G, Fast 3G, or Slow 3G throttling with matching CPU slowdown - the same conditions your slowest real user is on, on demand.
A full axe-core pass on every run - violations, impact level, exact selectors, and help links. Not a $30/month add-on, part of the run.
A full resource waterfall and a first-party vs third-party domain breakdown, so a slow page stops being a mystery.
Load Forge
Bounded load testing with real user scenarios, not just a request flood.
Replaces a standalone load-testing platformA fixed request count with ramp-up, a fixed-duration soak, or staged ramp-soak-spike profiles that scale virtual-user concurrency across stages - k6-style, without leaving the dashboard.
Each virtual user can run a full multi-step scenario - log in, extract an auth token from the response, reuse it under load in every following step. Realistic traffic, not a GET loop.
p95, p99, error-rate, and minimum-throughput budgets - any one violated flags the run as failed, with a breakpoint report showing exactly where it broke.
Every scripted step is host-locked to the same validated target and passes the same SSRF checks as the rest of the platform. It cannot be pointed at someone else's infrastructure.
Record it once. Trust it forever.
Most QA recorders generate brittle scripts tied to a CSS class that breaks the moment a designer ships a redesign. The Flow Lab recorder does something most competitors don't bother with: it verifies its own work.
- A ranked selector strategy - test id, then ARIA role, then visible text, then a stable id or name - picks the selector most likely to survive a redesign, not the first one that matches.
- Record in-app, streamed live from a hosted browser session, or fully local with the
wqaCLI - same engine, three ways in. - Every generated step replays itself before it's inserted into the suite. Anything that doesn't resolve is reported with a reason - not silently dropped, not discovered three weeks later mid-run.
Run QA for ten clients without their data ever touching.
Organizations partition every site, run, schedule, and notification at the data layer - not by convention, by construction. A report link for Client A cannot leak into Client B's dashboard. Each organization gets its own alert channels - Slack, webhook, SMTP, Twilio SMS - even when two clients share the same destination.
Alerts that land exactly where your team already works.
Every organization gets its own integrations and its own rules - not one global on/off switch buried in a settings page nobody opens.
- Four channels, mixed per organization. Generic JSON webhooks, Slack incoming webhooks, SMTP (Gmail, SES, SendGrid, Postmark, or your own server), and Twilio SMS/voice escalation - enable exactly the ones a client needs, not the ones you don't.
- Alert rules down to the trigger. Run completed, run failed, export created, manual runs, scheduled runs, live vs. staging environment, recovery events - each toggled independently, with template fields for summary counts, failed sites, and run links.
- Scoped API keys and a real audit log. Issue API keys per integration, and see every mutating action - who did it, when, from where - attributed and scoped to the organization it happened in.
Every run becomes proof, not just a log line.
Every check, journey, performance run, and load test drops evidence into one Reports library - exportable in the format whoever's asking for it actually wants, and comparable side by side the moment something changes.
- Export in the format they'll actually open. HTML, PDF, Markdown, JSON, JUnit XML, and ZIP with embedded screenshots - per run, per module, or in bulk from the Export Center.
- Compare any two runs. Catch a regression by diffing the current run against a baseline, right in the dashboard - not by eyeballing two separate PDFs.
- One evidence trail across every module. Watchtower checks, Flow Lab journeys, Speed Lab diagnostics, and Load Forge stress runs all land in the same Reports library, scoped to the organization that owns them.
Security isn't a bullet point we added later.
Every user-supplied target - Watchtower sites, Flow Lab suites, Speed Lab and Load Forge runs - is validated before it runs. Localhost, private IPs, link-local, reserved ranges, and embedded credentials are all blocked.
SMTP passwords, webhook URLs, Twilio tokens, and Basic Auth credentials are encrypted at rest and masked on read - nothing sensitive sits in plaintext in the database.
Scheduled and manual runs execute on a Redis-backed queue in a separate worker process. Restarting the API does not kill a run in progress - tested live by restarting the API mid-run and watching the job survive.
Every meaningful change - who did it, when, from where - is recorded, attributed to an account or an API key, and scoped to the organization it happened in.
Every site, run, suite, schedule, and notification is scoped to an organization at the data layer. A report link for one client cannot leak into another's - by construction, not convention.
What you get with one tool instead of four.
| Web QA OS | Uptime monitors | Synthetic E2E clouds | Visual regression tools | Load testing tools | |
|---|---|---|---|---|---|
| Uptime & health monitoring (DNS, TLS, headers, redirects) | |||||
| Recorded browser journeys with self-healing selectors | |||||
| Visual regression with pixel-diff baselines | |||||
| Real-browser Web Vitals (LCP/CLS/TBT) | |||||
| Built-in accessibility audit (axe-core) | |||||
| Load testing with staged ramp/soak/spike profiles | |||||
| Data-driven, CSV-parameterized test runs | |||||
| JUnit XML export for native CI integration | |||||
| Multi-client data isolation (Organizations) | |||||
| One login, one bill |
partial support in some tools in the category - varies by vendor.
One plan replaces the whole stack.
Every plan includes Watchtower and Reports. Higher tiers add modules and headroom, not gated features you have to beg support to unlock.
Starter
For one site that just needs to stay up and prove it.
- 5 monitored sites
- 100 Watchtower checks / month
- 2 schedules
- 30-day run history
Pro
For teams shipping regularly across more than one property.
- 50 monitored sites
- 1,000 / 300 / 300 monthly runs
- 20 schedules
- 25 Flow Lab suites
Scale
For agencies and platforms running QA across a whole portfolio.
- 250 monitored sites
- 10,000 / 2,500 / 2,500 / 500 monthly runs
- 100 schedules
- 250 Flow Lab suites
Enterprise
For portfolios, self-hosted deployments, and dedicated SLAs.
- Self-hosted / on-prem option
- Custom retention & SLA
- Dedicated support channel
Stop stitching five dashboards together.
One platform for uptime, QA journeys, performance, and load - built and run by the same team that builds production systems for a living.
Coming Soon - Reach Out for Early Access