A QA automation platform your team owns, built in 90 days
We build the platform, not your test suite. It deploys into your stack, gives your team one interface to run and monitor automation, and puts AI agents to work turning your requirements into runnable Playwright tests.
Free pilot Hosted wherever you want No licence, no per-seat
Reads your requirements
Jira, Confluence, or a spreadsheet row
Writes against your code
Your fixtures, your page objects, your naming
Stops at review
Draft pull request, scoped to test paths
Integrated with the tools your team already uses
- Jira
- Zephyr Scale
- Confluence
- Playwright
- GitHub Actions
- Google Sheets
- Slack
- PostgreSQL
- Allure
- Claude
- Jenkins
Anything with a REST API is realistic to add during the build
/// The problem
Three gaps, and none of them close by hiring.
Writing tests
Every new feature waits for someone who knows Playwright.
Automation is bottlenecked on the few people who can write it, so coverage trails the roadmap permanently.
No control plane
Six tools, and nowhere to actually run anything.
Cases in one system, specs in a repo, runs in CI, screenshots in a zip nobody opens, triage in a Slack thread that scrolls away.
Coverage nobody trusts
Your coverage number is maintained by hand.
Which means it is wrong the day after it is written, and everyone in the room already knows it.
An automation hire takes months to ramp and leaves with the context. A record-and-playback tool charges per seat and keeps your tests in its own format. We build you a platform instead — one your team owns, that writes its own tests.
/// The interface
One console. Catalogue, runs, triage, coverage, proof.
The place your team actually works. Open it, see what is covered, trigger a run against the environment you care about, read a root cause on every failure — without touching a terminal.
Authoring
Agents write the tests
Point an agent at a Jira ticket or a requirements page. It drafts a runnable spec that reuses your existing page objects instead of inventing selectors, and opens it as a pull request for your team to review.
Execution
Run anything from the interface
One case, one module or the whole suite. Headed when someone wants to watch the browser, headless and parallel when nobody does.
Catalogue
Test cases synced both ways
Cases pull in from Zephyr Scale, Jira or Google Sheets with their steps and priorities. New ones push back out.
Triage
Every failure arrives with a root cause
An agent reads the trace, video and screenshots read-only, then classifies the failure as selector-drift, timing, test-data, environment, app-bug or test-logic-bug — with its evidence.
Coverage
Coverage derived from the code
Computed from the spec files, never typed into a spreadsheet. A validation run demotes anything that stopped passing.
Proof
A screenshot for every test, pass or fail
Browsable per run, with traces and video kept on failure. When someone asks whether a flow was really tested, you open the gallery.
Access
Your team, your roles, your branding
Logins with custom permissions, invitations, and test environments whose credentials are managed in the UI and encrypted at rest. Put your own name and colours on it.
Illustrative run detail · your modules, your test IDs, your branding
/// How it works
Four steps. The first is free, the last is your team.
STEP 01 · FREE
Pilot
Two weeks. We stand the platform up against your app, wire one environment, and get the agents drafting specs from your real requirements. Yours to keep either way.
STEP 02 · 3 MONTHS
The build
Your catalogue synced, every integration you need wired in, and the agents tuned against your app until their output is code your engineers merge without rewriting.
STEP 03
Deployed where you want it
Your cloud account, your own servers, or entirely behind your VPN. Provisioned as code, so the deployment is reproducible and auditable.
STEP 04 · ONGOING
Handover, then hours
Your engineers get the repo, the conventions and a written runbook, in working sessions. After that you buy hours when you want them — no retainer, no licence.
/// The pilot — free
We build it once, for free, on your real requirements.
Automation platforms get sold on slide decks and bought on faith, which is why so many are abandoned by the second quarter. So we skip the deck: give us two weeks and a slice of your real requirements, and we will build the thing.
Not a demo against a toy app — your app, your tickets, your environment. If it lands, we scope the build. If it doesn’t, you keep it and we have lost two weeks. That is the right way round, because we are the ones making the claim.
Book the intro callCall → working platform · about two weeks
What the pilot delivers
- INTRO CALL30 minutes. Your stack, your tools, and which flow breaking would hurt most.
- WEEK 1The platform running against your app. One environment wired, your cases imported from Zephyr Scale, Jira or a spreadsheet.
- WEEK 2Agents drafting specs from your real requirements, runs triggerable from the interface, failures arriving with root causes.
- HANDOVERA walkthrough call, then it is yours. No invoice, no contract.
- IF IT LANDSWe scope the three-month build. Fee fixed before anything starts.
- IF IT DOESN'TYou keep the pilot and we are done.
/// What you get at handover
Everything needed to run it without us.
A good enablement engagement is judged by what your team can do the month after it ends.
- The platform: catalogue, run triggering, run history, coverage, proof screenshots, settings
- Agents that turn your requirements into runnable Playwright specs
- Agent triage that gives every failure a root cause before a human looks
- Two-way sync with your test-management tool
- CI wiring and Slack notifications that lead with failures
- Infrastructure-as-code for the deployment, and a written runbook
/// Engagement
Three phases. The first one is free.
We don't publish a figure, because one quoted before seeing your integration surface would be padded or wrong. What we commit to: the pilot costs nothing, the build fee is fixed before it starts, and afterwards there is no retainer and no licence.
Pilot
Free
~2 weeks
The platform running against your app, with agents writing real tests.
No contract · yours either way
- Platform deployed and running against your app
- One environment wired, credentials managed in the UI
- Your test cases imported from Zephyr Scale, Jira or a Sheet
- Agents drafting specs from your real requirements
- Runs triggerable from the interface, headed or headless
- Core build
Build
3 months engagement
Fixed monthly fee
The full platform: your integrations, your environments, deployed and handed over.
Fee fixed before we start
- Everything in the pilot, plus:
- Your full catalogue synced both ways
- Every integration you need, wired in
- Agents tuned to your app's conventions and selectors
- Roles, permissions and environments for your team
- Deployed to your own infrastructure as code
- Runbook and handover sessions with your engineers
Support
By the hour
After handover
Platform work when you want it, and none when you don't.
No retainer · no minimum · no licence
- New integrations as your tooling changes
- Features your team wants but doesn't want to build
- Framework upgrades and agent tuning
- A hand when something breaks
Bring your test-management tool and roughly how many cases you have. That's enough for a fee and a timeline on the call.
/// Why it holds up
"A failing test is not automatically a broken test. An agent asked to make a red test green will nearly always succeed — usually by changing the test."
That single risk is why most AI-written test suites quietly stop being worth anything. So the platform is built to protect the signal instead: coverage is derived from the code rather than declared, a validation run demotes anything that stopped passing, triage reads traces read-only, and generated code lands as a draft pull request scoped to test paths. Failures classified as app-bug are excluded from auto-fixing outright — if the product is wrong and the test is right, no agent gets to make that red test green.
6
Root-cause categories triage must choose from
0
Auto-merged AI changes — draft pull requests only
100%
Coverage derived from code, never typed by hand
/// Frequently asked
The questions that actually matter.
Who writes the tests — you or us?
Your team does, with the agents doing most of the typing. To be direct about the boundary: we build and deploy the platform, we are not your outsourced QA department. During the build we tune the agents against your app until their output is specs your engineers merge without rewriting, and the pilot proves that on your real requirements before you commit to anything. After handover your team owns the suite and it grows at your pace, not ours.
What exactly is the free pilot?
About two weeks of our time, no invoice and no contract. We stand the platform up against your app, wire one environment, import a slice of your real test cases, and get the agents drafting specs from your actual requirements. You get it running, you drive it yourself, and you keep it whether or not we go further.
What is the AI allowed to do — and not allowed to do?
It drafts test cases and specs from your requirements, and it investigates failures. The limits are the point. Investigations are read-only and cannot edit a file. Generated code is restricted to an allowlist of test paths, syntax-checked, discarded entirely if the agent touched anything outside it, and always opened as a draft pull request against a development branch — never merged, never on main. Failures classified as app-bug are excluded from auto-fixing, because if the product is wrong and the test is right, no agent gets to make that red test green. Everything runs under a cost cap, on a provider API key your company owns.
Which tools does it integrate with?
Already built and running in production: Zephyr Scale (read and write, including test steps), Jira, Confluence, Google Sheets (two-way, many tabs, results written back), Slack, GitHub Actions and Jenkins. Anything with a REST API is realistic to add during the build — TestRail, Qase, Xray, Azure DevOps, Linear. If your test cases live in a spreadsheet nobody wants to admit to, that is genuinely the easiest case.
Where does it run, and what does it cost to keep running?
Wherever you want it: a cloud account, your own servers, or entirely behind your VPN with no public exposure. It needs one modest instance and a Postgres database, so the hosting bill is small — and it is your bill, not a licence. There is no per-seat cost because there is no vendor. The only variable cost is AI usage, billed to a provider API key your company owns — so it appears on your provider invoice with no markup from us, capped per run.
What happens when you leave?
That is the goal, not a risk to manage. Your team gets the repository, the conventions, the infrastructure-as-code and a written runbook covering how to add a module, debug a flake and tune the agents. Nothing phones home, there is no kill-switch and there is nothing to renew. We are available by the hour afterwards, but the platform does not need us — if it did, we would have built the wrong thing.
/// Book an intro call
30 minutes. Then two free weeks on your real requirements.
You'll leave the call with a scope, a timeline and a fixed fee — and if the pilot is worth doing, we start it without a contract. No card, no procurement, no follow-up sales sequence.
Book an intro call →Or email support@anchorly.co — replies within one business day.