Skip to content
Qualio AI

Early access · Playwright + GitHub Actions

E2E tests that write, run and heal themselves, inside your CI.

Qualio turns tickets into Playwright tests on your pull requests, gives every failure a verdict, and fixes UI drift on its own. It never hides a real bug. The tests live in your repository; your app never leaves your CI.

Animated walkthrough of a pull request in Qualio. Three tests run in CI; two fail. Qualio gives each failure a verdict: a renamed link is a UI change, 96% sure, so it fixes the locator from Classes to Courses, checks it finds exactly one element, and the re-run passes. Saving a student returns a server error: a possible bug, 94% sure, which is never healed; the pull request author and the ticket reporter are alerted.

How it works

From a ticket to green tests, without leaving your pull request

Qualio works on top of the tests you already have. Nothing is generated until a ticket asks for it.

  1. Add one workflow

    Commit .github/workflows/qualio.yml in a setup pull request. Your app starts in the job, exactly as it does today.

  2. Qualio learns your app

    The first run maps every page through its accessibility tree, signed out and as each role, then reads your existing tests into features.

  3. Tickets become tests

    A Jira ticket or a plain-English request becomes a spec, then Playwright tests on the pull request that names it.

  4. Failures get a verdict

    Bug, UI change, flaky, environment and more, with a confidence score and evidence. Drift is healed and suggested on the pull request.

Self-healing

Fixes test drift. Never patches over a bug.

Every failure gets a verdict, how sure Qualio is, and what it is based on: the ticket, the spec, the domain knowledge and a live look at the page. Fixes are checked in your CI job before you ever see them.

  • UI change (can be healed)
  • Planned change (can be healed)
  • Flaky (can be healed)
  • Test problem (can be healed)
  • Bug (never healed automatically)
  • Unexpected change (never healed automatically)
  • Environment (never healed automatically)
  • Bugs are never healed, whatever the model, the setting or a person says. Server errors, failed requests and missing controls are caught in code.
  • Every fix can be reverted in one click, with the locators before and after and the run that proved it.

Choose how readily Qualio heals

  • Supervised Every fix

    Qualio proposes every fix; a person accepts it with one click.

    Regulated teams, or your first weeks.

  • Balanced Default From 85% sure

    UI changes Qualio is sure about are healed; everything else is proposed.

    The default for most teams.

  • Autonomous From 70% sure

    Heals everything except bugs, and proposes when unsure.

    Fast-moving UIs with many renames.

Below the confidence bar, a fix is always proposed rather than applied. Unexpected changes always wait for a person.

Everything a QA engineer does

An autonomous QA agent that works the way your team already does

  • Jira Cloud, built in

    Pick a board column such as "Ready for QA". Its issues become tickets, and the conversation happens right on the issue.

  • Workbench chat

    No ticket? Describe what to test in plain English. The Analyst asks only the questions that change the tests.

  • Domain knowledge

    One living document of your rules, roles and features, rewritten whenever a spec is approved. No stale wiki.

  • Tests you would write

    Strict Page Object Model with ARIA-first locators (getByRole, getByLabel), typechecked before they run.

  • Adopts your suite

    Already have Playwright tests? Qualio reads them into features on the first run, then heals and extends them.

  • One report per pull request

    A single comment, edited in place: bugs, what needs you, self-healed fixes. No notification spam.

  • Live diagnosis

    When a test fails, Qualio can look at the running app in your job's browser before it decides, look-only.

  • Specs don't wait for people

    Approved automatically by default, or switch to "Ask me first" per project.

Security & data

Built for teams that can't hand over their code

Qualio is designed so it doesn't need your source code, your network or your secrets.

  • Zero-firewall ingress

    Qualio never reaches your app. Mapping and tests run inside your GitHub Actions job, on your runners.

  • Credentials stay in CI

    Test account passwords live only in GitHub secrets (E2E_<ROLE>_PASSWORD). Qualio never stores them.

  • No code access

    The optional GitHub App has no Contents, Pull requests or Workflows permission. Your job sends only the tests folder.

  • Only its own branches

    Qualio pushes only qualio/* branches. Every change reaches you as a suggestion or a pull request a person merges.

  • Keys hashed, tokens encrypted

    Project API keys are stored hashed and can be rotated or revoked. Jira tokens are encrypted at rest.

  • Prompts are not kept

    Every AI call is metered for cost and audit. Prompts and responses are never stored.

Setup

One workflow file. That's the integration.

Qualio's setup wizard pre-fills it for you; open it as a pull request, and its first run maps your app and reads your tests.

  • Works with the Playwright tests you already have, or none at all
  • All settings live in the workflow, reviewed like any other change
  • Add a test account per role as a GitHub secret
# .github/workflows/qualio.yml
name: Qualio E2E
on:
  pull_request:
    types: [opened, synchronize, reopened, closed]
  workflow_dispatch:

jobs:
  e2e:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Start the application
        run: npm ci && npm start &
      - uses: qualio-ai/qualio-action@v1
        with:
          api-key: ${{ secrets.QUALIO_API_KEY }}
          base-url: http://localhost:3000
          config: |
            version: 1
            tests:
              path: e2e
            self-healing:
              sensitivity: balanced  # or supervised, autonomous
            roles:
              - name: Admin
              - name: Teacher

FAQ

Questions, answered

What do I need to use Qualio?

A web app that can start in a GitHub Actions job, and a GitHub repository. Tests are Playwright + TypeScript; if you already have some, Qualio adopts them.

Does Qualio see my source code?

No. Your CI job sends only the tests folder and the overview documents you name in the workflow. The GitHub App has no permission to read code, and Qualio pushes only its own qualio/* branches.

What if a self-heal is wrong?

Every fix is verified by a run in your CI before it is suggested, says why it was made, and can be reverted in one click. Rejected fixes teach Qualio and are never applied again by themselves.

Can it hide a real regression?

No. Functional breakage such as server errors, failed requests or a control that vanished is detected in code and is never healed, whatever the setting. You get a "possible bug" alert instead.

Do I have to use Jira?

No. Tickets can be pasted, sent through the API, or started as a plain-English chat in the Workbench. A pull request that names no ticket gets its spec agreed in the pull request comments.

How much does it cost?

We're in early access and working closely with a small group of teams. Join the waitlist or email hello@qualio-ai.com and we'll talk it through.

Stop babysitting your E2E suite

Join the early-access waitlist and we'll be in touch when there's a spot for your team.