Donobu Logo

Own your tests.

Two questions decide whether a test suite is actually yours: what format it's written in, and where it runs. With Donobu, both answers point to the same truth: you are the owner.

Book a demoGet a free QA snapshot
What you keep
tests/checkout.spec.ts
import { test } from 'donobu';

test('user can complete checkout', async ({ page }) => {
  await page.goto('/checkout');
  await page.getByLabel('Promo code').fill('SAVE10');
  await page.getByRole('button', { name: 'Apply' }).click();
  await page.ai.assert('The discount was applied to the total.');

  await page.getByRole('button', { name: 'Complete purchase' }).click();
  await page.ai.assert('The order is confirmed.');
});
Deterministic replay
npx playwright test
Deterministic replay. No fresh AI calls.
The two questions

The two questions that decide ownership

Most teams don't ask either question until it's too late, usually the day they try to leave a vendor and discover the tests don't come with them. Ask these now:

What format is it written in? If the answer is a proprietary format only one company's engine can read, you don't have a test suite. You have a file that, if you're lucky, only describes one.

Where does it run? If the answer is "inside our cloud," running your own tests requires that vendor's infrastructure to stay up, their prices to remain unchanged, and them to stay in business. That's not a technical detail. It's a dependency on someone else's company.

Donobu's answers: Playwright in TypeScript, with Donobu's extensions on top, running on your machine or your VPC.

Format

The format: Playwright in TypeScript, extended by Donobu

Every test Donobu writes is native Playwright in TypeScript, with the Donobu Playwright Extension on top. The source reads like any Playwright spec your engineers already review by hand, and it's checked into your repo like any other code you own: same code review, same version control, same CI. The extension is where the features that make a suite worth keeping come from, natural-language assertions, self-healing, automated failure triage, but there's no recorded macro or black-box format underneath. It's still Playwright under the hood.

Where it runs

Where it runs: your machine, your VPC, not a hosted black box

Donobu runs local-first. Testing happens on your machine or inside your own VPC, not inside a hosted cloud test runner where your pre-release product has to leave your environment to get checked. You can also bring your own model key: Donobu works with Claude, Gemini, and OpenAI models, and the key stays local. Nothing about authoring a test requires trusting a third party with your product.

Replay

Once a suite exists, it runs in your pipeline, not ours

Authoring a test uses AI: an agent explores, proposes actions, and, in SUPERVISED mode, waits for your approval. Running an already-authored test is different. DETERMINISTIC mode replays it exactly, without fresh AI inference, directly inside your own CI/CD, so the tests in your pipeline don't get slower, flakier, or more expensive to run as your suite grows. And when a run does need a model, for a natural-language assertion, a self-heal, or triage, that call can go through the Donobu API or through a model key you bring yourself. If Donobu the company disappeared tomorrow, you'd point the suite at your own LLM of choice and keep running it.

Ownership

Renting a tool versus owning a test suite

That's the difference between renting a testing tool and owning a test suite. A Playwright test in your repo is an asset: your engineers can read it, change it, run it, and delete it. A test trapped in a format only one vendor's engine can read is a subscription with extra steps. It looks like an asset on a dashboard. It behaves like a bill.

FAQ

Frequently Asked Questions

Can we leave? What do we actually keep?

You keep every test: Playwright TypeScript files in your own repo, not records in our cloud. They import the Donobu Playwright Extension for self-healing and natural-language assertions, so leaving looks like one of two paths. Keep the extension and point it at your own model key instead of the Donobu API, and the suite keeps running as-is. Or, as a last resort, a simple migration takes the tests down to plain Playwright: you give up the extension's features, but your coverage was never trapped in a proprietary harness.

What format are the tests in?

Playwright, in TypeScript, importing the Donobu Playwright Extension: a library on top of standard Playwright that adds natural-language assertions, self-healing, and automated triage. It's not a DSL or a recorded macro. The source reads like the tests your engineers already write, and it's still Playwright under the hood.

Where does Donobu actually run?

Local-first: on your machine, or inside your own VPC. Your product and pre-release data stay in your environment. You also bring your own model key, which stays local too.

Do we need Donobu to keep our tests running?

You need the Donobu Playwright Extension the tests import, not our cloud. DETERMINISTIC replay runs a reviewed test without fresh AI inference, and when a model call is needed, it can go through the Donobu API or a key you bring: Donobu works with Claude, Gemini, and OpenAI models. If Donobu the company vanished tomorrow, you'd switch the suite to your own LLM and keep running it, and a simple migration down to plain Playwright remains the escape hatch of last resort.
Get started

Ready to own what Donobu builds for you?

Book a demo