Seven services, one platform. What each one does, the problem it solves, and how it works. They share a single setup: connect your app once and switch on whichever you need.
🪄 Testnova Auto
From a sentence to a passing test.
What it does
Testnova Auto turns plain words into working tests. Describe a feature in plain English, or upload a requirements document or a design image, and Testnova writes the test cases, generates the automation scripts, runs them, and opens a pull request to add the passing tests to your codebase. The pipeline: Requirements → Test Cases → Test Scripts → Test Run → Report.
How it works
Type your requirement or upload a document or design. Testnova scans your live app, writes the test cases, then turns them into Playwright scripts grounded in your real UI. You review and approve, run them to see pass or fail, and Testnova opens a pull request to add the passing tests to your repo, then emails a plain-English report.
Why Testnova
Writing automated tests the usual way means a specialist turning each requirement into code by hand, and most of that code breaks because it guesses at your buttons and fields. Testnova Auto does the whole chain for you. You describe a feature in plain words, or hand it a document or a design, and it writes the cases, builds scripts that target your real app, runs them, and opens a pull request so the passing tests land in your own repo. You review everything before it is pushed, so you get the speed of automation without losing control or getting locked in.
What you get
From plain words to working tests. Describe a feature in a sentence, or upload a requirements document or a design image, and Testnova writes the cases and the scripts for you.
Scripts that target your real app. Testnova scans your live screens first, so tests point at your actual buttons and fields instead of guesses, which makes them far more reliable.
Nothing to set up. There is no framework to stand up. You go from a written requirement to a running test in one connected flow.
Runs in the right order. Testnova understands which cases depend on others, so a delete never runs before its create.
Your tests live in your repo. Once a script passes, Testnova opens a pull request in your own GitHub, so there is no lock-in and the suite stays yours.
You approve before anything ships. Every generated script waits for your review, so you only keep the tests you trust.
Traceability and coverage. A live matrix links each requirement to its test cases, runs and any bugs found, with a coverage percentage that shows exactly what is tested and what is not.
Reports anyone can read. Every run produces a plain-English summary a PM, founder or client can follow at a glance.
Testnova Explorer is an autonomous AI agent that tests your web application from end to end, without a single test case written in advance. It explores your app like a curious first-time user, finds real bugs, and reports them with clear, step-by-step instructions your developers can act on right away.
How it works
You provide your application URL, plus a saved login if your app needs one. Explorer opens a real browser and explores your app on its own, page by page and flow by flow, while you watch live. When it finishes, you get a report of every issue it found, each with steps to reproduce, plus optional Slack alerts and Jira tickets.
Why Testnova
Most testing tools cannot do anything until someone writes the test cases first, and hiring a QA engineer to explore every release by hand is slow and expensive. Testnova Explorer needs neither. You point it at your app and it explores on its own like a curious user, gets past logins that block other tools, and hands you only the bugs that survive a second skeptical pass. Every finding comes with the exact steps to reproduce it, so your developers can act right away instead of guessing.
What you get
A QA tester on demand. Point Explorer at your app and it tests like a real user, with no QA engineer to hire and no waiting for a freelancer to be free.
Zero test cases needed. Explorer discovers your flows by itself, logging in, walking the happy path and then probing the edges.
Gets past real logins. Save your login once and Explorer reuses that session, so OTP, two-factor and passkeys do not stop it at the front door.
Only real bugs reach you. One pass finds issues and a second skeptical pass tries to disprove each one, so you are not buried in false alarms.
Steps your developers can follow. Every finding includes how to reproduce it, what was expected, what happened, a severity rating and the evidence behind it.
Honest about coverage. Explorer tells you exactly which pages and flows it tested, and which sensitive areas like payments and deletions it stayed away from.
Results where your team works. Findings land in your inbox, with optional Slack alerts and automatic Jira tickets for the serious ones.
The biggest hidden cost of test automation is maintenance. Every time a developer renames a button or moves a field, scripts break. Testnova Self-Heal detects what changed, repairs the affected scripts automatically, and re-runs them to prove the fix works, so your suite stays green for the right reasons. The workflow: Pull from repo → Auto-heal broken scripts → Run to verify → Push back. Test management is now zero effort.
How it works
Connect your project. When a test breaks, Testnova re-scans your live app and tries fast, free rule-based fixes first; if that is not enough, it regenerates the script with AI. It re-runs the script to confirm the fix works, logs exactly what changed, and can push the healed script back to your repository as a pull request.
Why Testnova
The hidden cost of test automation is not writing the tests, it is keeping them alive. Every renamed button or moved field breaks a script, and teams end up spending more time repairing tests than writing new ones, until they quietly give up on the suite. Testnova Self-Heal watches for those breaks and fixes them for you. It tries a fast, free repair first, regenerates the script with AI when the change is bigger, and re-runs it to prove the fix really works. Your suite stays green for the right reasons, and every repair is logged so you always know what changed.
What you get
Breaks get fixed automatically. When a button is renamed or a field moves, Testnova spots the change and updates the affected scripts on its own.
Most fixes cost nothing. Simple breaks are repaired instantly by free, rule-based fixes, with no AI cost and no manual editing.
A green run you can trust. Self-Heal re-scans your live app, repairs the script and re-runs it, so a pass means the feature genuinely works.
Handles the big changes too. When a quick fix is not enough, Testnova regenerates the script against your current app using AI.
Your suite stays alive. Scripts are kept current with your app instead of rotting until the whole suite is abandoned.
A clear audit trail. Every repair is logged, what broke and how it was fixed, so you have a record you can review.
Fixes flow back to your repo. Healed scripts that pass can be pushed straight to GitHub as a pull request.
Functional tests tell you whether your app works. Testnova Lens tells you whether it still looks right, reads right and loads fast enough. It captures every page at mobile, tablet and desktop sizes, compares them against an approved version, and flags anything that has visually changed: shifted buttons, wrong colors, broken layouts, overlapping elements or missing images. On the same pass it runs axe-core accessibility scans against WCAG 2.2 AA, with measured colour-contrast ratios, and checks Core Web Vitals and Lighthouse-style performance budgets. A developer can fix a bug and accidentally break the design, slow a page down or fail an accessibility rule. All functional tests pass. Testnova Lens catches what they missed.
How it works
Connect your application URL. Lens crawls your pages and captures each one at mobile, tablet and desktop sizes. It compares every page against your approved baseline, both pixel by pixel and with AI, and grades what changed: green for unchanged, yellow for a minor change, red for something that needs a look. On the same pass it runs axe-core accessibility scans against WCAG 2.2 AA with measured contrast ratios, and checks Core Web Vitals and Lighthouse-style performance budgets. When the run finishes, the full report is emailed to your team with side-by-side comparisons of every changed page.
Why Testnova
Your functional tests can all pass while a button quietly slips out of place, a color changes, a layout breaks on mobile, contrast drops below the accessible line or a page slows to a crawl, and usually nobody notices until a customer does. Checking every page by eye after each change is not realistic, so teams skip it. Testnova Lens does that check for you. It captures every page at phone, tablet and desktop sizes, compares them against an approved version both pixel by pixel and with AI, runs axe-core accessibility scans against WCAG 2.2 AA, and measures Core Web Vitals and performance budgets. It catches problems on the very first run with no baseline, and costs a fraction of the heavy enterprise tools built for the same job.
What you get
Catches what functional tests miss. Lens compares your pages against an approved version and flags shifts, wrong colors and broken layouts even when the app still works.
Sees problems before customers do. Broken spacing, overlapping elements and clipped text are caught first, with a side-by-side before and after of every change.
Every page, every size. Lens captures each page at phone, tablet and desktop sizes and reviews all three together, with nothing skipped.
Works on the first run. Beyond pixel comparison, Lens uses AI to spot overlaps, clipped text, broken images and poor contrast even before you have a baseline.
A living record of your design. Lens keeps an approved visual baseline and updates it as you sign off on intended changes.
Accessibility built in. Every page is scanned with axe-core against WCAG 2.2 AA, with each violation reported alongside the measured colour-contrast ratio behind it.
Performance budgets that hold. Lens measures Core Web Vitals and Lighthouse-style budgets, so a page that drifts slower is flagged before it reaches your users.
Plug and play. Connect a URL and get visual checks in minutes, without the complex setup and cost of tools like Percy or Applitools.
The whole team stays in the loop. Run Lens any time and it emails everyone a visual report the moment it finishes.
Testnova Runner is your test infrastructure, fully managed in the cloud. No virtual machines to set up, no CI runners to maintain, no DevOps. Connect your code and your existing tests run on real browsers in the cloud, in parallel, on demand or on every pull request. Plug and play. No setup. No DevOps. Just your code and results. (Real-device mobile / Appium runs are on the roadmap.)
How it works
Connect your GitHub repo or upload your test suite. Runner detects your framework, then runs your tests in the cloud: Playwright, Cypress and Pytest on managed machines, and a built-in engine for APIs (real-device mobile / Appium is coming soon). Watch runs live, side by side, and get a report emailed the moment they finish, along with JUnit XML and Allure results that drop straight into your CI dashboard.
Why Testnova
Most teams either maintain their own test infrastructure, which quietly eats engineering time, or juggle several disconnected tools for web, API and CI. Testnova Runner gives you all of it in one place. It runs the tests you already have without a rewrite, fixes them when they break, exports JUnit XML and Allure results so the run shows up natively in your CI dashboard, and only charges for the minutes you actually use. You get a managed cloud test runner and a CI pipeline without hiring anyone to run them.
What you get
No infrastructure to maintain. Fully managed cloud runs, with no Selenium grids and no CI runners to set up or babysit.
Run your existing tests, no rewrite. Runner clones your repo and runs your Playwright, Cypress, Pytest and API tests exactly as they are. Bring your own code.
Every browser in the cloud. Cross-browser testing on managed cloud machines, with no grid to run. Real-device mobile (Appium) is coming soon.
Continuous, automated runs. Schedule nightly runs or trigger on every pull request, so regression testing never gets skipped under deadline pressure.
Faster feedback through parallelism. Many tests run at once in the cloud and you watch them live, side by side, instead of waiting on one machine.
Less maintenance with self-healing. When a selector breaks, the AI re-grounds and repairs the script instead of failing, so fewer runs flake out.
One dashboard, one report. Web, mobile and API results, screenshots and logs in one place, emailed with a PDF the moment a run finishes.
CI-native results. Every run exports JUnit XML and Allure results, so it plugs straight into GitHub Actions, GitLab, Jenkins or any CI dashboard with no glue code.
Pay only for what you run. Per-minute billing with no idle infrastructure cost, cheaper than running your own grid and device lab.
Testnova API turns your API specification into a complete, running test suite, for REST and GraphQL alike. Point it at your OpenAPI or Swagger file, your GraphQL schema, or just your endpoints, and it writes the positive, negative, boundary and security checks for every route, runs them against your live API, and tells you what passed and what broke. It validates every response against its JSON schema, signs in with the auth your API uses including OAuth2 token flows, and runs the same suite across your dev, staging and production environments. You get thorough API coverage without writing a single line of test script.
How it works
Connect your API by sharing its spec, a GraphQL schema, a base URL or a sample request. Testnova reads your endpoints, learns the request and response shape of each one, and writes test cases that cover the happy path, the error cases, the edge values and the common security holes. It authenticates the way your API expects, including OAuth2 token flows, and validates every response against its JSON schema so a changed or missing field is caught immediately. It chains calls that depend on each other, so it can create a record, read it back, update it and clean up on its own. Switch environments and the same suite runs against dev, staging or production. It runs everything against your live API, checks each response against the contract, and emails a plain-English report when it finishes.
Why Testnova
Tools like Postman are great at sending a request, but they leave the hard part to you. Someone still has to write every assertion by hand, wire up the calls that depend on each other, remember the negative and security cases, and repair the whole collection every time the API changes. Testnova does that work for you. It builds the suite from your spec, covers the cases people usually skip, fixes the tests when an endpoint changes, and lives in the same platform that tests your screens and your mobile app. One suite and one report for everything behind your product.
What you get
A full suite from your spec. Hand Testnova your OpenAPI or Swagger file and it writes test cases for every endpoint, so you start with coverage instead of a blank screen.
No scripting required. Describe what to check in plain English. There is no JavaScript to write, so your whole team can read and trust the tests.
The cases people skip. Every route gets negative, boundary and security checks like missing fields, wrong types, auth bypass and injection, not only the happy path.
Tests that fix themselves. When an endpoint adds or renames a field, Testnova repairs the affected tests instead of leaving you a broken collection.
Chained workflows handled for you. It creates a record, reads it back, updates it and cleans up on its own, with no IDs to wire between calls by hand.
REST and GraphQL. Hand Testnova an OpenAPI spec or a GraphQL schema and it builds the suite either way, so the API behind your product is covered whatever shape it takes.
JSON-schema validation. Every response is validated against its JSON schema, so a missing field, a wrong type or an undocumented addition is flagged the moment it appears.
Real auth and environments. Testnova signs in the way your API expects, including OAuth2 token flows, and runs the same suite across your dev, staging and production environments.
Contract and drift checking. Every response is checked against your spec, so breaking changes and undocumented fields are caught before your customers find them.
One platform for UI, mobile and API. The same tool that tests your screens tests the APIs behind them, in one suite with one report, instead of another tool to manage.
Plain-English reports. Results land in your inbox in language a PM or founder can read, with the failing request and response attached for your developers.
Testnova Security scans your running application the way an attacker would meet it, from the outside and while signed in. It crawls your real pages, then runs a bounded battery of checks: access control between different accounts, injection, session and cookie handling, and accidental exposure. Every finding comes back with a severity and a confidence level, so you can tell a confirmed hole from something that merely looks suspicious. It is safe by default, and the more aggressive checks are opt-in rather than something you discover after the fact.
How it works
Point Security at your app and hand it a login, the same setup the other services use. It signs in, crawls your real pages, and runs the safe battery: it tries to reach one account’s data while signed in as another, probes inputs for injection, inspects how sessions and cookies are handled, and looks for secrets or debug detail leaking into responses. Each finding is graded by severity and by confidence, confirmed, observed, or potential, so nothing is presented as certain when it is not. The verdict is computed from the evidence the engine actually collected, not decided by a language model. Aggressive checks that could disturb your app are opt-in, and the whole run is bounded so a scan never becomes an outage.
Why Testnova
Most security scanners meet your app as a stranger: signed out, at the front door, seeing the login screen and little else. The bugs that hurt live behind the login, where one customer can reach another customer’s records. Testnova Security is already signed in, because it shares the same setup and saved session as the rest of your testing, so it can test the authenticated surface where real breaches happen. It grades what it finds by confidence, so it does not hand you a hundred maybes and call it a report, and it follows the same rule as everything else in Testnova: a finding is evidence, not a guess.
What you get
Tests the authenticated app. It runs signed in, so it reaches the pages behind your login, which is where the serious bugs live and where most scanners never go.
Access control between real accounts. It signs in as more than one identity and tries to reach data across them, the check that catches one customer seeing another customer’s records.
Severity and confidence, separately. Every finding says how bad it is and how sure we are. A confirmed hole and a maybe are never dressed up as the same thing.
Safe by default. The standard scan is bounded and non-destructive. Aggressive checks are opt-in, so a security run never becomes an incident.
No model decides pass or fail. The verdict is computed from the evidence the engine collected, so the result is repeatable rather than an opinion that changes between runs.
One setup for everything. The same project, login and session that power your functional testing power your security testing, so there is nothing new to configure.
Reports anyone can act on. Findings arrive in plain English with the evidence attached, so a developer can fix it and a founder can understand it.
Want the engineering behind the verdicts rather than the feature list? Read Inside Testnova, which covers the mechanisms that make a FAILED result trustworthy, service by service.