Repo-native testing

Your Playwright suite, in your git.

Connect a repository and the suite in it becomes your test list. vikingQA keeps no second copy. It reads your code, runs it, and makes each change through a pull request. You merge it yourself, or you turn on automatic merge and vikingQA merges it for you.

Every test is plain Playwright in your git. Cancel tomorrow and you keep every test.

Add guest checkout test
vikingqa/guest-checkout → mainChecks passed
tests/checkout/guest-checkout.spec.ts
import { test, expect } from '@playwright/test';

test('Guest checkout', async ({ page }) => {
  await test.step('Add a product', async () => {
    await page.goto('/products');
    await page.getByRole('button', {
      name: 'Add to cart'
    }).first().click();
  });
  await test.step('Check the cart', async () => {
    await expect(page.getByText('1 item'))
      .toBeVisible();
  });
});
Connect

Connect one repository in three steps.

01

Choose the repository

Connect GitHub or GitLab and select the repository that holds your tests. On GitHub, you install the vikingQA app and grant access to that repository only. On GitLab, you sign in and select the project.

02

Choose the branch

Name your first environment and the branch it follows. Most teams start with Staging on main.

03

Review what vikingQA found

vikingQA reads your Playwright configuration and lists your tests. You see the count before you finish.

No suite yet? Connect an empty repository. The agent and the recorder fill it.

The test list

Your folders, tags and steps, read from your code.

vikingQA does not ask you to import, convert or tag anything again. It reads what your code already says.

In your repositoryIn vikingQA
A test() in a .spec.ts filea test case
The file paththe folder
Playwright tags such as @smoketags you filter and select by
test.step() blocksthe steps a non-developer reads
test.skip and test.fixmea skipped test, reported as skipped
A committhe exact version a run used

The list stays current. vikingQA syncs when you push, checks again every hour, and syncs before each pipeline run. You can also sync by hand.

Branches

Each environment follows a branch.

An environment is a name and a branch. Staging can follow main while Production follows your release branch. Each environment shows the tests that exist on its branch and runs them at a known commit.

  • A test added on main appears in Staging first. It appears in Production when the branch gets it.
  • Each run records the commit it ran.
  • Variables and secrets are set per environment.
Pull requests

Agent-written tests arrive the way all code arrives.

vikingQA commits the agent's work to a vikingqa/ branch and opens a pull request against your base branch (a merge request on GitLab). Each later change in the same chat is one more commit on the same pull request. You merge it yourself, or you turn on automatic merge and vikingQA merges it for you.

  • Your branch protection and your CI checks apply. vikingQA merges only when your git host reports the pull request as mergeable.
  • The pull request description says what the test covers.
  • Testers follow the status of their change in vikingQA. They do not need a git account.
Your tests, your git

Leave tomorrow. Keep every test.

Every test is plain Playwright in your git. Cancel tomorrow and you keep every test.

  • The files import from @playwright/test and nothing else of ours.
  • npx playwright test runs the suite on your laptop and in your CI.
  • The repository is the only copy.
  • Running your committed Playwright tests costs no AI credits.
Write rules

Narrow access, by design.

01

What vikingQA does

  • Reads your repository to list and run your tests
  • Creates branches whose name starts with vikingqa/
  • Commits test files to those branches
  • Opens pull requests from those branches
  • Merges its own pull request into the branch it was opened against, when automatic merge is on for the project
02

What vikingQA never does

  • Push to your default branch
  • Push to a branch that is not a vikingqa/ branch
  • Force-push
  • Delete a branch
  • Merge a pull request when automatic merge is off for the project

The product enforces these rules before a push leaves our system. The agent cannot override them, and a push to any branch outside vikingqa/ is refused.

On GitHub, the vikingQA app asks for Contents, Pull requests and Metadata on the repositories you select.

Questions about repo-native testing.

We already have a Playwright suite. Do we start over?

No. Connect the repository and your suite becomes your test list. The agent adds to it and maintains it.

Do we need to change our Playwright configuration or add a package?

No. vikingQA runs the suite with the Playwright version your repository declares. There is nothing of ours to install in the repository.

Does our own CI still run the tests?

Yes. Run in the vikingQA cloud, or in your own CI: the tests are plain Playwright in your repository. You can do both.

Can we use a monorepo?

Yes. Select the repository and vikingQA follows the Playwright project it finds there.

What happens to tests that fail to load?

vikingQA lists the files it could not load and names the spec file that needed each one. Nothing disappears from the list without a reason.

What does vikingQA store outside our repository?

Run results and evidence, test case metadata such as run history, and the agent's chat sessions. It does not store a second copy of your test code as the source of truth.

What happens if we cancel?

Nothing happens to your tests. They stay in your repository and keep running in your CI.

Keep your Playwright. Add a colleague that writes more of it.

Connect a repository and see your suite in vikingQA in minutes.