Early access The free plan is live — 2 tests, no card, yours to keep Get started →
QAright
Try free

Automated testing without the code, or the maintenance.

Click through your app and QAright builds the test. When your screens change, it repairs itself.

Get started free See how it works
qaright.com/tests/submit-new-claim

Submit new claim

READY ▶ Run test
Last run ✓ Passed 2h ago Chromium · UAT
Steps 6 Natural Detailed
1 step Open the customer portal at app.everline.example
2 steps Sign in as a policyholder
1 step Confirm the policy list loaded
1 step Start a new claim
1 step Choose Accidental damage as the claim type
Record by using the app. Your clicks become steps in plain English, readable by anyone on the team.
Built to stay trusted

A suite that survives your own release cycle.

Suites are rarely deleted. They fail once, someone adds a retry, and quietly stop being read. Three deliberate choices keep this one worth opening.

Resilient

Fourteen ways to find every element

Each element is captured with a ranked set of locators rather than one. When the DOM shifts, the next candidate takes over — so a cosmetic change stays cosmetic instead of arriving as a product failure.

Legible

Every result explains itself

You get the cause in plain English — the id went dynamic, a cookie banner was covering the button — and any repair is written down where you can read it back and disagree with it.

Early

You hear about drift before CI does

Guardian re-walks your recorded pages on a schedule, or on every deploy, and reports what moved while the suite is still green — rather than at 2am, in front of everyone.

How it works

Record once. Keep it running.

Click through your app in a real browser. QAright captures the intent behind each action, not just the coordinates.

qaright.com/tests/submit-new-claim

Submit new claim

READY HIGH PRIORITY History Suite ▶ Run test
Last run ✓ Passed 2h ago 6 steps Chromium · headless · UAT
Steps
1 step Open the customer portal at app.everline.example
2 steps Sign in as a policyholder
1 step Confirm the policy list loaded
1 step Start a new claim
1 step Choose Accidental damage as the claim type
The same test, two ways. Natural groups the steps into readable actions, so someone who has never seen the app can review what the test does. Detailed is the same list with the resolved locator for each step and the +5 fallbacks standing behind it. The toggle here is the real control — try it.
Capture

Every element, described several ways

At record time each element is described by up to fourteen candidate locators — test ids, ARIA role and name, label association, scoped CSS paths — and each one is scored for how likely it is to survive the next deploy.

  • Dynamic ids, UUIDs and framework-generated classes are detected and pushed down the ranking, never used as the primary.
  • Candidates are checked for uniqueness as they are captured, so an ambiguous selector is flagged before it ever runs.
  • Shadow DOM, slotted content and same-origin iframes are pierced to a concrete element rather than stopping at the host node.
  • A DOM snapshot is stored per step — the raw material every later repair is checked against.
candidates · "Submit claim"score
// ranked at record time, highest first GetByRole("button", name: "Submit claim") 96 GetByTestId("claim-submit") 94 GetByLabel("Submit claim") 81 form.claim >> button.primary 64 #btn-a7x9f2 15 ← dynamic
Run

Watch it execute, and step in mid-run

Runs stream live over the wire. Pause between steps, inspect the variables the scenario has captured so far, edit a step that is about to run, and resume — without restarting the scenario.

  • Pause, resume and cancel at clean step boundaries — never mid-action.
  • Per-step retries, timeouts and wait strategies, configurable per step.
  • Full-page screenshots on failure, with an optional per-step timeline.
  • Run in parallel across Chromium, Firefox and WebKit.
run · checkout-happy-path11 / 12
04Fill "Card number"210 ms
05Select "Expiry month"96 ms
06Click "Continue" · healed340 ms
07Assert URL contains /review45 ms
08Click "Place order"running
Export

Leave whenever you like

Every suite exports to a self-contained C# Playwright project — the test, the resilient execution engine, the data generators and a project file. It compiles and runs with dotnet test, with or without QAright.

  • Readable page objects generated from your recorded app model.
  • The same healing logic ships inside the export, so exported tests keep their fallbacks.
  • No proprietary run format and no lock-in — it is a normal .NET project.
checkout-happy-path.zipdotnet test
GeneratedTest.cs ResilientTestEngine.cs PlaywrightHelpers.cs ScenarioContext.cs TestDataGenerator.cs CheckoutTests.csproj .runsettings
Self-healing

An ordered chain, not a guess

When the primary locator misses, QAright works down a defined cascade. Each phase is logged, so a repair is always something you can read back and disagree with.

healing cascadephase
  1. Primary locatorThe highest-scoring candidate from record time.
  2. Fallback candidatesRemaining candidates in rank order, each probed for presence and uniqueness.
  3. App model lookupThe element is matched against the crawled model of your application.
  4. Semantic scanInteractive elements on the live page are scored against the recorded DOM snapshot.
  5. AI-assisted repairOptional, and only if you enable it. The snapshot is sent to a model you configure.
Rules the engine will not break

Healing that refuses to be clever

Most flaky automation comes from a tool guessing confidently. The cascade is deliberately conservative.

  • Never heal an assertion. A broken path to an element is recoverable. An element found in the wrong state is a real failure and is reported as one.
  • Never resolve ambiguity by guessing. If a candidate matches several elements and scores poorly, it is refused rather than picked.
  • Never invent a candidate. Healing re-ranks what capture recorded; it does not fabricate selectors from a stale DOM.
  • Never silently rewrite your test. A fallback is promoted to primary only after it has worked three runs running — and the promotion is written to the audit log.
Guardian

Find the drift before the suite does

Guardian walks your recorded pages on a schedule — or on every deploy — and compares what it finds against the DOM snapshots captured when you recorded. It reports what moved while the suite is still green.

qaright.com/guardian
Guardian. Each scan reports drift per URL and rolls it up to a risk level per test, so you can tell a cosmetic change from one that will block the suite.

Proactive, not reactive

You get told a test id disappeared on the payment page on Tuesday morning, not when the nightly run goes red on Friday.

Scoped by page, not by test

Drift is reported against the page that changed, so one navigation rewrite shows up once rather than as thirty separate failures.

Gets past your login

Guardian replays a recorded login segment to reach authenticated pages, so coverage doesn't stop at the sign-in screen.

Platform

The rest of what a real suite needs

Recording is the easy part. Everything below is what makes a suite survive contact with more than one engineer.

qaright.com/analytics
Test Analytics. Pass rate, execution volume and duration over any window, with the pass/fail trend underneath.

Environments

Point the same suite at local, UAT, staging or production. URLs and credentials live in the environment, never in the test.

Data profiles & tokens

Named datasets plus generated values. {{env.KEY}}, {{data.key}}, {{faker.EMAIL}} and {{capture.VAR}} resolve at run time.

Tags & filtered runs

Tag cases and run subsets. smoke,regression to include, ~slow to exclude.

Visual timeline

Compressed screenshots per run, full-page on failure, with baselines for comparison and a lightbox on every step.

Analytics

Pass-rate trend, slowest steps, flaky and consistently broken cases, and per-run performance metrics.

API steps

Mix HTTP calls into a browser scenario — seed a record, capture a value from the response, then assert on it in the UI.

CI/CD triggers

POST to /api/trigger with an API key from GitHub Actions, Azure DevOps, GitLab or Jenkins. Block on the result or poll it.

Teams & roles

Organisations, projects, role-based access, version history on every case and an audit log of who changed what.

Element inspector

Click any element in a live page to see its candidate locators, their scores, and whether each one is actually unique.

Where it runs

Your browsers, your network, your data

Healing runs locally. That is an architectural choice, not a pricing tier — and it has consequences worth knowing about.

Nothing is shipped out to heal

Repairs are computed from candidates and snapshots you already hold. Your DOM is not sent to a third party to be analysed.

Works air-gapped

No outbound call is required for a run to succeed, so QAright works on isolated networks and behind strict egress rules.

AI is opt-in and yours

The AI healing phase is off unless you enable it, and it calls the model endpoint you configure — under your key, your region, your retention.

Pricing

Priced per person, not per test run

Run as often as you like. You are never charged for executing a test, so nobody has to ration the suite to stay in budget.

Free

Anyone who wants to see whether this works on their app.

$0/ forever

No card. One seat.

Get started free
  • 2 tests and 1 suite — run them as often as you like
  • Ranked locator candidates with stability scoring
  • Self-healing cascade and healing report
  • Element inspector and assertion builder
  • Reports, screenshots and analytics
  • One export to C#, and one try of each AI feature

Solo

One engineer keeping a suite alive alongside everything else.

$29/ month

Billed monthly. One seat.

Start on Free
  • Everything in Free, plus
  • Unlimited tests, suites and runs
  • Unlimited export to a standalone C# Playwright project
  • Monthly AI allowance for generation, crawling and repair
  • Shared step libraries and an editable app model
  • Up to 3 projects, and PDF/CSV report export
Most teams

Team

A QA team sharing suites across environments and a pipeline.

$79/ user / month

Billed monthly. 3 to 10 seats.

Start on Free
  • Everything in Solo, plus
  • Guardian proactive drift detection
  • Environments, data profiles and shared tokens
  • Parallel cross-browser runs, up to 4 at once
  • Scheduled runs, CI/CD triggers and API keys
  • Unlimited projects, roles and user management
  • Version history and audit log

Enterprise

Regulated environments, private networks, and procurement.

Custom

Annual agreement.

Talk to us
  • Everything in Team, plus
  • Single sign-on via Microsoft Entra ID
  • Self-hosted or air-gapped deployment
  • Multiple organisations under one tenant
  • Bring your own AI endpoint and keys
  • Named support contact and onboarding

The free plan is real and stays free. Paid pricing is not final during early access and may change at general availability — if you join now on a paid plan, we will tell you before anything moves. Every plan runs on your own infrastructure, and your tests export to plain C# whenever you want to leave.

Questions

The things people ask first

Do I need to know how to code?

No. Recording, editing and running a suite is entirely visual, and each step can be read as a plain-English description. If you do write code, every suite exports to a normal C# Playwright project you can own outright.

How is this different from recording with Playwright directly?

Playwright's own codegen records one selector per action. That is fine until the DOM moves. QAright stores a ranked set of candidates, scores them for stability, repairs at run time, and keeps a history of what it repaired.

QAright is built on Microsoft Playwright and runs real Playwright underneath — the difference is what happens after the recording.

Doesn't self-healing just hide real bugs?

It would, if it healed assertions — so it doesn't. The cascade only repairs the path to an element. If the element is found and its state is wrong, that propagates as a failure immediately.

Every repair is also logged and surfaced in the run report, so a test that only passes because it was healed is visible rather than silently green.

What happens to my tests if we stop paying?

You export them. Suites become a self-contained .NET project that compiles and runs with dotnet test, including the resilient execution engine and your recorded fallbacks. There is no proprietary run format holding your work hostage.

Can it test an app behind a login?

Yes. Authentication is recorded once as a reusable preamble and replayed to establish a session, which the suite and Guardian both reuse. Credentials live in an environment, not in the test.

Which browsers are supported?

Chromium, Firefox and WebKit, headed or headless, and a suite can be run across several of them in parallel in a single execution.

Bring us your flakiest suite.

The free plan is how you start, and during early access we set it up with you rather than leaving you at a sign-up form. Tell us what you are testing and we will have your workspace ready. If you have a suite people have quietly stopped trusting, that is exactly the one we want to see.

Get started free Book a walkthrough

Opens your mail app. Free forever, and no card.