Ship a build.
Get back evidence.
A URL, an APK, an FRS document, or just screenshots — that's all Pulse needs. AI drafts the test cases, runs them, and reports back. You keep the judgment calls on what ships.
Every feature exists because manual QA bleeds time somewhere.
This is the map. Each pain point has a specific answer, built into the product — not bolted on.
Requirements arrive in any form — FRS docs, images, or "here's the app, figure it out"
Multi-modal AI generation with a live streaming feed. No format is off-limits.
New features land and test cases lag behind
Incremental generation, a coverage Q&A bot with one-click gap-fill, and AI editing.
Organising smoke, sanity, and regression packs
Suites as packs, Flows chaining suites, Rounds per manual cycle.
Execution is slow, manual drudgery
One-click manual recording with evidence; one-click automated runs with a live view.
Reporting eats a QA lead's entire week
Auto pass/fail, AI root cause per failure, executive reports, PDF/CSV export, email alerts.
"Can we actually trust this coverage?"
Traceability to source, case-type mix, honest gap surfacing, a full evidence trail.
Ship it to us. We test it. We ship it back.
Every stage feeds the next without a manual translation step. The FRS is the input to generation. The generated case is the executable spec. The failure is the defect draft. The results are the report.
Intake
A URL, an APK upload, an FRS document, or screenshots — however the build already exists.
AI Generation
Features → sub-features → typed test cases, identified and watched live as they're discovered.
Execution
Manual rounds with one-click evidence, or automated runs via the Pulse Agent with live screenshots.
AI Analysis
Every failure classified — real bug, flaky, or environment — and linked to the case it breaks.
Reports Out
Executive summary, PDF, CSV, email — generated automatically, not written by hand.
Ship Back
With coverage proof, evidence, and a prioritised risk list — ready for the sign-off call.
Feed it anything. Get back a full test hierarchy.
FRS documents, screenshots, a plain-English description, or just a URL — Generation accepts all of it, and produces a Feature → Sub-feature → Test case hierarchy, streamed live as Claude reads through your material. No prerequisite steps.
- FRS documents (PDF / .docx) parsed and grounded automatically
- Screenshots alone are enough — generate multi-modally, no text required
- Every test case classified as Positive, Negative, or Edge at generation time
- Traceable via a source reference back to the exact requirement it came from
- Real runnable code from day one — Playwright for web, WebdriverIO/Appium for Android
Ask about your test cases. Fill the gap in two clicks.
"Ask about your test cases" answers questions like this strictly from your real cases, citing the exact TC-00N cases that support the answer. When coverage is missing, it proposes a ready-to-use test case with a one-click Add button.
- Grounded answers only — the bot never invents coverage that isn't there
- Any test case or whole sub-feature can be edited with a natural-language instruction
- Edits are previewed first, applied only on confirmation
- The Coverage dashboard closes the loop — unclassified cases, never-executed cases, missing negative/edge coverage
Smoke tests, regression packs, manual cycles — however your team already thinks about testing.
The concepts map directly onto constructs your team already knows.
Name suites as packs — "Smoke — checkout", "Sanity — auth" — each one-click runnable.
Chain suites on a canvas — session (cookies/login) carries across stages, so later suites start authenticated.
Manual execution scoped per round per platform, with per-round reset and reporting.
Suites tagged Website / Android / iOS — the Execution dashboard groups by platform.
Manual when you need control. Automated when you need speed.
The Execution dashboard is built for speed — every case gets one-click Pass / Fail / Blocked, with an expandable panel only when you want notes and evidence. The Run Suite button dispatches automated specs to a Pulse Agent: a single standalone binary, no Node install needed.
- Manual: filter by status, case type, epic, or free-text search
- Automated: live results and live screenshots stream back per test
- Real-world blockers handled — a waitForOtp helper polls for codes via Twilio or Mac Messages
- Quick Launch — open any URL on an agent machine for an instant eyeball check
Saved card autofill breaks after the payment-form refactor merged this morning
Reporting is generated, not written.
Confidence comes from a system that can't flatter itself.
Per automated run
Pass/fail/skip counts and durations, plus AI root-cause analysis on every failure: probable cause, contributing factors, suggested fix, confidence score, and a classification — real bug, flaky, environment, or bad test data.
Executive report per run
Plain-English summary, key risks, recommendations, and trend versus the prior run — exportable to PDF for the people who don't open the dashboard.
Per manual round
CSV export and a formatted PDF execution report — project, platform, round, per-case status, type, and notes.
Coverage dashboard
Case-type mix is visible — a suite that only tests happy paths is immediately obvious. Gaps are surfaced, not hidden: 88% never-run shows as 88% never-run.
Evidence trail
Manual executions attach screenshots and recordings. Automated failures capture screenshots. Every defect carries both.
Alerts
Email notification on run completion, so nobody has to poll a screen waiting for results.
Pulse doesn't wait for you to check.
Every run completion, every failure, every report — pushed straight to your phone the moment it lands. You don't have to babysit a dashboard to know what's happening.
- Real-time push notifications on iOS and Android
- AI root cause summarised right in the notification — no dashboard required
- Daily and weekly digest options, so urgent and routine stay separate
- Notification rules per project, so you only hear about what matters
A native app, not a shrunk-down dashboard.
Eleven screens, one continuous story: summary, live runs, failure evidence, AI root cause, defect triage, and executive reports — each built for a phone from the ground up, not squeezed from a desktop layout.
- Summary — every project's pulse, with the single most urgent thing surfaced first
- Runs & Run detail — live status on every suite, with a Stop control while it's running
- Failure detail & AI root cause — raw error, screenshot, and a fix written for a non-engineer
- Projects & Project pulse — per-project health, suites, and machine status
- Defects & Defect detail — triage with repro steps and evidence, from a phone
- Reports & Change detail — executive summaries, and every AI edit shown as a before/after diff
Anything that can curl can trigger a run.
Runs are dispatched via plain REST — POST /api/runs with a suiteId — including from a CI job. The agent is a portable standalone binary that connects outbound over websockets, so there are no inbound firewall rules to negotiate.
- Install the agent on a build machine, a QA laptop, or a VM
- Flows chain suites into regression pipelines, also dispatchable via API
- Agent state reconciles on API restart — a dead agent can never silently absorb a dispatched run
Ship your first build.
Point Pulse at a URL, upload an APK, or drop in an FRS document. Watch the test hierarchy build itself.
Get Started →