The whole loop, not a recorder
Four jobs most tools leave to you. Verity does all four.
Generate
Describe a flow or drop a URL. Verity writes a runnable Playwright spec in TypeScript — role-based locators, real assertions, ready to run.
Maintain
When a selector breaks, Verity proposes the fix from the live DOM. Flaky tests are re-run and separated from real failures, so noise never blocks a merge.
Verify
A forward-deployed engineer turns disposable AI scripts into a maintained Page Object Model suite they own — the part automation alone never gives you.
Predict
Regression-prone files, flake-vs-real calls, and a deploy confidence score — posted right inside the pull request, before you ship.
How it works
One pipeline. From commit to confidence.
# .github/workflows/verity.yml
- name: Verity — Quick check (every PR commit)
uses: qashift/verity-action@v1
with: { tier: fast, token: ${{ secrets.VERITY_INGEST_TOKEN }} }
- name: Verity — Full regression (on merge to main)
if: github.ref == 'refs/heads/main'
uses: qashift/verity-action@v1
with: { tier: full, token: ${{ secrets.VERITY_INGEST_TOKEN }} }We label it honestly
A fast check is not a safety net. We never pretend otherwise.
Speed, on every commit
Runs only the tests mapped to your changed files. Fast feedback in the PR — a sanity check, explicitly not full coverage. It can never block a merge.
The real safety net
The entire suite on merge, schedule, or pre-deploy. No diff-aware shortcuts, ever. This is the only tier allowed to block a merge.
Everything the suite needs to stay alive.
AI test generation
From a sentence or a URL to a runnable spec. Zero setup to your first test.
Self-healing locators
Broken selector → AI-proposed fix from the live DOM, surfaced as a diff you approve. Never silently merged.
Two-tier execution
A fast diff-aware Quick check on every commit, and a Full regression suite on merge — honestly labeled, never conflated.
Flake detection & quarantine
Suspect failures re-run N times; flaky is split from broken; per-test flake rate tracked over time.
Confidence scoring
Not just pass/fail — does a green test meaningfully cover a critical path, or is it technically-green theatre?
Managed POM conversion
Our FDEs restructure flat AI scripts into a maintainable Page Object Model — the moat that makes tests an owned asset.
The intelligence layer
Verity doesn't just run your tests. It tells you what's about to break.
Every run feeds a model of your codebase: which files regress, which tests lie, and how risk compounds. Two signals are live today; two more switch on automatically once your project has enough history.
Regression-prone modules
LiveFiles with a high historical regression rate for similar changes — flagged inline in the PR, before review.
Flaky vs. real failures
LiveEvery failure is scored against its own flake history, so noise is quarantined and real blockers stand out.
Cross-dimension correlation
CalibratingHow regression, failure and flake signals move together across deploys. Switches on once there's enough history.
Deploy confidence score
CalibratingOne decomposed score per deploy. Calibrates against your history before it's shown — never a number you can't trust.
In the product, these surfaces show your real data— and an honest empty state until there's enough of it. We never invent a number to fill a chart.
AI writes. Engineers verify. Neither works without the other.
Generated tests are disposable until someone owns them. On every paid plan — from Starter, a forward-deployed engineer joins your team: they convert AI scripts into a maintainable Page Object Model, keep the suite green as your product changes, triage every failure, and tune the predictions to your codebase. You get the output of a QA team without building one.
See plans with an engineer →Try it in the cloud. Live in your CI. Hand it to an FDE.
Cloud is for the first feel — it's capped on purpose. The product is built to run in your pipeline, where it's unlimited.
Generate a spec and run a few times on our infra — no setup. Capped, because this is the demo, not the product.
Minutes to first test
Wire one workflow in. Unlimited Quick checks and Full regressions in your own pipeline — we never host your browsers.
Unlimited runs, flat price
A forward-deployed engineer builds, owns and maintains the suite end-to-end. AI + platform + a human accountable for it.
A QA team, without hiring one
Why Verity
The only one that does generation, maintenance, prediction — and a human.
| Verity | DIY Playwright | AI per-test tools | Managed QA agency | |
|---|---|---|---|---|
| AI generates the tests | manual | |||
| Self-healing locators | some | manual | ||
| Flaky ≠ broken (auto-triage) | rare | manual | ||
| Runs in your own CI | sometimes | |||
| Regression & risk predictions | ||||
| A human engineer owns the suite | from Starter | |||
| Flat pricing, unlimited runs | free but DIY | per-test meter | retainer | |
| You own the code (POM, MIT core) | lock-in | varies |
Security & data
Built so your code and secrets stay yours.
Verity is designed for teams that can't hand their codebase to a SaaS. The architecture keeps execution in your infrastructure and gives us the least access that still does the job.
Your browsers and secrets never leave your CI
Verity is CI-native. Tests run in your own pipeline against your own environments. We never host your browsers or receive your app secrets — only test results and metadata are sent to us.
Tenant isolation with row-level security
Every row is scoped to an organization and enforced in the database with Postgres RLS. One customer can never read another's projects, tests, or runs.
Scoped, revocable ingest tokens
CI authenticates with a per-project token that can only post results for that project. Rotate or revoke it any time — no broad API keys, no standing access to your repo.
We never write to your source
Self-healing proposes a corrected locator as a diff you approve. Verity has no write access to your code — a human always lands the change.
Least-privilege GitHub App
The app requests only Pull requests, Checks and Contents (read). Webhooks are HMAC-signed and verified on every call. No org-wide or account permissions.
Auditable, open-source core
The execution and scoring engine (@qashift/verity-core) is MIT-licensed and inspectable. The model that decides flaky-vs-real and risk is not a black box.
Enterprise plans add SSO/SAML, RBAC, and SOC 2 / GDPR support via the QAShift platform. Security questions? hello@qashifthq.com.
Pricing
Start free. Self-serve at $49. Add an engineer when ready.
Verity's self-serve tiers below. The forward-deployed-engineer tiers (Starter and up) — with mobile, performance, security, and predictions — share one canonical price across the QAShift platform.
Cloud Sandbox
Get the feel instantly in our cloud sandbox — no card.
- ✓AI test generation, UI — 15/month
- ✓Try it instantly in our cloud sandbox
- ✓Unlimited CI runs once you wire your pipeline
- ·Self-healing and flake triage start at Self-Serve Pro.
Self-Serve Pro
The full engine, self-driven. No engineer, no call.
- ✓AI test generation, UI + API — 200/month
- ✓Self-healing locators + flake detection included
- ✓Unlimited CI runs
- ✓3 projects
Want an engineer on it?
Starter, Growth, Scale, and Enterprise include a forward-deployed engineer, mobile, performance, security, and predictions. All four tiers live on the QAShift platform pricing page.
Same pricing across the QAShift platform. View the full canonical pricing →
Generate your first test in 30 seconds.
Try it free in the cloud, wire it into your CI, or hand the whole suite to a forward-deployed engineer.