How to Do QA Without a QA Team: Setup for Small Teams (2026)
An 8-step QA setup for small teams with no QA hire: money-path test flows, a pre-release checklist, Playwright, exploratory runs, escaped-bug tracking.
A five-engineer startup ships three or four times a week, and coding agents write a large share of the code. Nobody's job title says QA, so most bugs are found by customers and arrive as support tickets days after the release that caused them. This guide from the BuildBetter team gives you an 8-step QA setup that a small team can run with a spreadsheet, a shared doc, and about two weeks of part-time effort. It includes a worked two-week example, the mistakes that sink most attempts, and the point at which you should add tools or hire your first QA engineer.
What 'QA without a QA team' actually means
QA without a QA team is a lightweight system in which engineers share responsibility for release quality. The team defines the user journeys that matter most, checks them before every release, automates the stable ones, and tracks which bugs reach customers.
The team owns this as a written process with a named owner each week. It is a different thing from testing that happens when someone has a spare hour. Spare-hour testing disappears on busy weeks, and busy weeks are when the riskiest changes ship.
The goal is also narrower than most teams expect. You are trying to catch the bugs that cost money or customers. You are not trying to catch every bug. This follows the risk-based testing principle in ISTQB and ISO/IEC/IEEE 29119: test effort should be proportional to how likely a failure is and how much it would hurt. A misaligned icon on an admin page and a double charge at checkout are both bugs. Only one of them belongs on a small team's release checklist.
Expectations for the method below:
- Budget: none required. Everything works in a spreadsheet and a shared doc.
- Setup time: about two weeks of part-time work from one or two engineers.
- Ongoing time: 20-30 minutes per release, plus a weekly owner rotation.
The 8 steps in one line: list your money-path journeys, write them as test flows, add a pre-release checklist, automate the stable flows, run exploratory checks, require reproduced bugs before fixing, rotate a weekly QA owner, and track escaped bugs.
Why QA breaks on small teams that ship fast
QA breaks on small teams because no one is assigned to check the paths customers depend on, so customers end up doing the checking. The failure modes are predictable, and they compound as release frequency goes up.
- Customers become the test suite. Without a defined check, the first person to run the signup flow after a change is a paying user. The bug shows up as a ticket, often days later, after the context of the change is gone.
- Developers test the path they built. An engineer verifies the happy path of their own change and misses the adjacent flow it broke. A change to auth middleware passes its own tests and quietly breaks billing settings.
- Coding agents raise output faster than review capacity. More pull requests per week means more changing surface area per release, while human checking stays flat. Google Cloud's DORA Accelerate State of DevOps Report 2024 found that a 25% increase in AI adoption was associated with an estimated 7.2% decrease in delivery stability, with larger change batches as one likely cause. In the 2025 Stack Overflow Developer Survey, the most common frustration developers reported with AI tools was solutions that are “almost right, but not quite.” Almost-right code passes the author's happy path.
- “Everyone owns quality” means no one does. With no named owner, the pre-release check gets skipped on the busy release.
- Bug reports are not reproducible. “Checkout is broken for some users” leads to an hour of guessing, a speculative fix, and a reopened ticket.
- There is no feedback loop. Teams don't count escaped bugs, so they can't tell whether quality is improving or which journeys keep breaking.
The stakes are real at every scale. CISQ estimated the cost of poor software quality in the U.S. at $2.41 trillion in 2022. NIST's older 2002 study put the annual cost of software errors at $59.5 billion and estimated that better testing infrastructure could remove about a third of it.
Self-diagnosis. You need this setup if:
- More than a third of your recent bugs were first reported by customers.
- Nobody can name who checked the last release, or what they checked.
- Your team has fixed a bug that turned out not to be the bug.
- You don't know which user journey broke most often last quarter.
The method: an 8-step QA setup for teams with no QA hire
The Money-Path QA Loop is an 8-step QA process for small teams that focuses testing on the user journeys that generate revenue or cause churn, and uses escaped bugs to decide what to test next. Every step works with a spreadsheet and no paid tooling.
Step 1: List the 5-10 journeys that make money or lose customers
Brainstorm every critical user journey, then keep only those that pass at least one of four filters:
- Revenue: does it generate money? (checkout, upgrade, renewal)
- Activation: does it gate a new user's first value? (signup, onboarding, first core action)
- Churn: would a break make customers leave? (login, data export, integrations)
- Support load: does a break flood the inbox?
Rank survivors by business impact times likelihood of change. Keep the list under 10. If you have 20 critical flows, you have none, because nobody runs 20 flows on a deadline.
Step 2: Write each journey as a test flow
Every flow needs a name, an exact start URL, an account state (such as “logged out” or “trial workspace with 3 projects”), 3-8 numbered steps, and an expected result a stranger could verify. Use this template:
| Flow | Start page | Account state | Steps | Expected result | Owner | Last checked |
|---|---|---|---|---|---|---|
| Login + password reset | /login | Existing user, verified email | 1. Click “Forgot password” 2. Enter email 3. Open reset email 4. Set new password 5. Log in | Reset email arrives within 2 min; new password works; old password fails | Priya | Nov 12 |
Step 3: Add a pre-release checklist
Before each release: run every money-path flow, check the changed areas plus one adjacent flow, test one mobile viewport, confirm error and empty states, confirm emails and webhooks fire, confirm the rollback plan, and check that monitoring is live. Time-box it to 20-30 minutes. This is a form of smoke testing: shallow, broad, and fast.
Step 4: Automate the most stable money paths
Pick 3-5 flows whose UI rarely changes, typically login, signup, and checkout. Write end-to-end tests with an open-source framework like Playwright and run them in CI on every merge to main. Mike Cohn's test automation pyramid explains the limit: end-to-end UI tests are the slowest and most brittle layer, so keep few of them. Do not automate flows that are mid-redesign.
Step 5: Run exploratory checks nightly or on each release
Exploratory testing, named by Cem Kaner and developed by James Bach, combines learning, test design, and execution at once. Use a time-boxed charter in Elisabeth Hendrickson's format: “Explore onboarding with invalid and non-ASCII inputs to discover validation and encoding failures,” for 20 minutes. The explorer can be a person or an AI agent running the same flows. Exploration finds what scripts cannot anticipate. See AI exploratory testing vs. scripted E2E tests for how the two divide the work.
Step 6: Require a reproduced bug before anyone fixes it
A valid report includes steps, expected result, actual result, environment and account state, and how many times it reproduced from a clean start. “Could not reproduce” is a valid outcome: log it and watch for recurrence. This rule stops speculative patches and wasted coding-agent runs. More detail in how to reproduce bugs with AI.
Step 7: Rotate a weekly QA owner
One engineer per week runs the checklist, triages incoming bug reports, reviews exploratory findings, and holds the release if a money path fails. Write down that the owner has authority to block a release. Rotation spreads product knowledge across the team and keeps one person from burning out.
Step 8: Track escaped bugs
An escaped bug is a defect a customer found before the team did. Log each one with the date, the journey affected, whether a test flow covered it, and severity. Review monthly. If an escaped bug hit an uncovered journey, add a flow. If it hit a covered journey, the check or script was too shallow, so add a step.
The 8 steps at a glance
| Step | Output artifact | Time to set up | Ongoing time per week |
|---|---|---|---|
| 1. List money-path journeys | Ranked journey list (5-10) | 2-4 hours | 15 min monthly review |
| 2. Write test flows | Test flow spreadsheet | 1-2 days | ~30 min of edits |
| 3. Pre-release checklist | Checklist doc | 2 hours | 20-30 min per release |
| 4. Automate stable flows | 3-5 E2E tests in CI | 3-4 days | 1-2 hours maintenance |
| 5. Exploratory checks | Charters + findings log | 2 hours | 1-2 hours |
| 6. Reproduce before fixing | Bug report template | 1 hour | Varies with volume |
| 7. Weekly QA owner | Rotation calendar | 30 min | Half a day for the owner |
| 8. Track escaped bugs | Escaped-bug log | 30 min | 15 min + 1 hour monthly |
Worked example: a two-week QA setup for a 5-engineer SaaS team
This is an illustrative scenario, not a customer case study. The setting: a B2B SaaS web app, 5 engineers, 3-4 releases a week, and roughly half of recent bugs first reported through support tickets.
Days 1-2: Pick the journeys
The team lists 12 candidates and cuts to 7 using the four filters: signup, onboarding to first project, invite teammate, connect integration, upgrade plan, export data, and login/password reset.
Cut: admin settings (low traffic, recoverable by support), profile photo upload (cosmetic), dashboard filters (high usage but failures are visible and non-blocking), notification preferences, and the changelog page. Each fails all four filters or has a cheap workaround.
Days 3-4: Write the flows
All 7 go into a spreadsheet. Here is one in full:
Flow: Upgrade plan
Start page: https://app.example.com/settings/billing
Account state: Trial workspace, admin user, test card on file, payment provider in test mode
Steps: 1. Click “Upgrade to Pro.” 2. Select annual billing. 3. Confirm with the saved test card. 4. Wait for redirect to the billing page. 5. Reload the page. 6. Open the test inbox.
Expected result: Plan badge shows Pro. Billing page shows annual Pro with a renewal date one year out. The payment dashboard shows exactly one charge. Invoice email arrives within 2 minutes.
Days 5-8: Script four flows
The team writes Playwright tests for login, signup, upgrade, and invite, and runs them in GitHub Actions on every merge to main. Integration-connect stays manual because it depends on a third-party OAuth screen that would make scripts flaky. Onboarding stays manual because its UI is mid-redesign and the script would break weekly.
Days 9-10: Exploration, checklist, and owners
Nightly exploratory runs start on all 7 flows, alternating between an AI agent and a 20-minute human charter. The pre-release checklist is drafted, and week 1 and week 2 QA owners are named in the team calendar.
Results across the two weeks
| Bug | Caught by | Reproduced | Decision | Why |
|---|---|---|---|---|
| Upgrade double-charged after back-navigation during confirmation | Scripted upgrade test (one-charge assertion) | 3 of 3 | Block release | Money path, direct revenue and refund risk |
| Invite email link pointed to staging | Pre-release checklist (“emails fire” item) | 2 of 2 | Block release | Every invite broken; 10-minute config fix |
| Onboarding stalled on a 360px-wide viewport | Exploratory check | 3 of 3 at 360px, 0 of 3 at 390px | Fix next release | Activation path, but narrow devices were a small share of onboarding starts and desktop was unaffected |
| Button misaligned on the export modal | Exploratory check | 1 of 3 | Accept and log | Cosmetic, intermittent, no functional impact |
The last row matters as much as the first three. Triage by severity and reproducibility is what keeps the system from turning into a backlog of trivia.
The escaped-bug log after two weeks
One bug escaped: a customer reported that CSV exports garbled names with accented characters. The log entry reads: Export data | covered by a flow: yes | severity: high (affects reporting for EU customers). The flow existed, so the check was too shallow. The team added a step: “Export a project containing non-ASCII names; open the CSV and confirm characters render correctly.”
Common mistakes when engineers own QA
Most small-team QA efforts fail from over-ambition at the start and erosion later, not from a lack of tests. Watch for these:
- Automating everything first. Teams spend three weeks building a flaky 40-test suite, stop trusting red builds, and abandon it. Start with 3-5 stable flows.
- Testing only the changed code. Regressions cluster at shared dependencies: auth middleware, billing, permissions, email templates, environment config. Always check one neighbor.
- Vague expected results. “Works correctly” cannot fail. “Plan badge shows Pro and invoice email arrives within 2 minutes” can.
- Fixing unreproduced bugs. This produces speculative patches, reopened tickets, and coding-agent runs aimed at the wrong problem.
- Letting the rotation lapse. The first release that ships without the checklist “just this once” is usually the one where it would have mattered.
- Not counting escaped bugs. Without the log, you can't show the process works or find its gaps.
- Trusting any automated or AI finding without checking the evidence. False positives waste engineering time. False negatives create false confidence. This applies to every tool, including BuildBetter.
Some problems no QA tool solves: unclear product requirements, no staging environment or seeded test data, missing monitoring and rollback, and no one empowered to stop a release. BuildBetter does not fix these either. Sort them out first, or every other step gets harder.
When the manual method stops scaling
A checklist and a rotating owner work at a few releases a month; at daily releases, no human checklist keeps up and unattended runs become necessary. Rough thresholds:
- A few releases a month: checklist plus rotating owner is enough.
- Several releases a week: add scripted tests in CI for the money paths.
- Daily or multiple-daily releases: add unattended runs, both scripted and exploratory.
Signals you've crossed the line: the checklist was skipped twice in a month, it takes longer than 30 minutes, escaped bugs rose two months in a row, or the QA owner spends more than a day a week reproducing reports.
Tools to add: BuildBetter QA Agent, Playwright, and Appium
| Tool | Type | Best for | Who maintains it | Cost |
|---|---|---|---|---|
| 1. BuildBetter QA Agent | AI exploratory QA agent | Nightly and per-release runs of the test flows you select, with reproduced findings | Admins edit which flows run | Unlimited seats, usage-based credits |
| 2. Playwright | Open-source E2E framework | Scripted regression tests on 3-5 stable money paths | Your engineers write and update tests | Free |
| 3. Appium | Open-source mobile automation | Scripted tests for native mobile apps | Your engineers | Free |
1. BuildBetter QA Agent — best for release testing without a QA hire
The BuildBetter QA Agent (Build > QA Agent) works as an AI QA team that tests your web app before each release and turns reproduced bugs into work. It explores your test flows, each defined by a start page and what it tests, checks layout, and retries suspected bugs from a clean start. Admins edit which journeys are included. Runs happen nightly or on a GitHub release trigger, and Run now handles on-demand checks. Each run uses credits, so review the selected flows and credit limits first.
Completed runs separate Verified bugs from Needs a look. Each finding includes steps, expected result, actual result, and a Reproduced count, plus a replay (exploration, repro 1, repro 2) next to the recorded agent actions. File to Inbox adds the bug to team work in BuildBetter Inbox/Triage, with Linear and Jira available. Send to hands the same brief to a coding agent. Because it lives in the same workspace as your customer calls, tickets, and signals, a bug and the customer complaints about it sit side by side. SOC 2 Type II, HIPAA, and GDPR compliant; pricing at buildbetter.ai/pricing. Setup walkthrough: how to test your app before every release with an AI QA agent.
2. Playwright
Playwright, released by Microsoft in 2020, drives Chromium, Firefox, and WebKit from one API, with auto-waiting, a trace viewer, codegen, and device descriptors such as devices['iPhone 13'] that cover the mobile-viewport check in the same suite. It is free; your team writes and maintains the tests.
3. Appium
If you also ship native iOS or Android apps, Appium gives you scripted mobile tests on an open-source base.
Recommended combination: scripted Playwright tests for the 3-5 stable money paths, plus exploratory agent runs across your other test flows. If you only need a handful of deterministic regression checks and have time to maintain scripts, Playwright alone may be enough.
When should a startup hire its first QA engineer?
Hire your first QA engineer when quality work consistently takes more than about a day per week of engineering time, or when you sell into regulated or enterprise buyers who require documented test processes. Before that, a rotating QA owner, written test flows, and automated runs usually cover a team of under 10 engineers.
Other triggers:
- Multiple product surfaces to cover, such as web, mobile, and a public API.
- Compliance audits that ask for test evidence and process documentation.
- Escaped bugs that cause churn or put a contract at risk.
- A test suite that nobody has time to maintain.
A first QA hire should own the system: strategy, test flows, tooling, and the escaped-bug review. If you hire someone to click through flows by hand, you've bought a slower version of what automation already does.
Can developers test their own code effectively?
Developers can test their own code effectively for unit and integration correctness, but they are poor at catching regressions in flows they didn't touch and at testing assumptions they built in. Pair self-testing with written test flows run by someone else, or by automation, before each release.
The mechanism is simple. The author knows the intended path, so they rarely try the unintended one. They enter valid data, click in the expected order, and test on their own screen size. This is the reasoning behind independent testing in ISTQB.
Practical fixes:
- The weekly QA owner, not the author, runs the pre-release checklist.
- An “adjacent flow” rule: for every change, ask what shares code with it and check that flow too.
- Exploratory charters that push on bad inputs, back-navigation, and interrupted sessions.
What should a pre-release checklist include?
A pre-release checklist should cover every money-path test flow, the specific areas changed in this release plus one adjacent flow, and the operational basics: monitoring, rollback, and migrations. It should take 20-30 minutes, have a named owner, and give that owner authority to block the release.
Copy this list:
- ☐ All money-path flows pass
- ☐ Changed areas verified against acceptance criteria
- ☐ One adjacent flow checked
- ☐ One mobile viewport checked
- ☐ Error and empty states render correctly
- ☐ Emails, webhooks, and integrations fire
- ☐ Database migrations reviewed and reversible
- ☐ Feature flags set correctly for this release
- ☐ Monitoring and alerts active
- ☐ Rollback plan confirmed
- ☐ Known issues logged
- ☐ Release notes drafted
Review and prune the list monthly against the escaped-bug log. Items that never catch anything can go; journeys that keep producing escapes need a new item.
Can AI agents replace manual QA?
AI agents can replace much of the repetitive manual QA work: exploring defined flows, checking layout, and reproducing suspected bugs from a clean start on a nightly or per-release schedule. They do not replace human judgment about what matters, which journeys to test, or whether a finding is worth fixing.
Humans still own journey selection, expected results, severity calls, and review of evidence such as replays and reproduction counts before anyone writes a fix. Agents also complement scripted tests rather than replacing them: scripts give deterministic pass/fail on known paths, and agents find the failures nobody wrote a script for. The comparison is laid out in AI exploratory testing vs. scripted E2E tests.
FAQ
How do you do QA without a QA team?
List the 5-10 journeys that make money or lose customers. Write each as a test flow with a start page, account state, steps, and a verifiable expected result. Run them on a 20-30 minute pre-release checklist, automate the 3-5 most stable with Playwright in CI, add nightly exploratory checks, require reproduced bugs before fixing, rotate a weekly QA owner, and track escaped bugs monthly.
How many test flows does a small team need?
Start with 5-10 flows covering the journeys that make money or lose customers. More than 10 at the start usually means none get checked consistently.
What is an escaped bug?
An escaped bug is a defect that a customer found before the team did. Tracking escaped bugs is the simplest measure of whether a QA process works.
What is the difference between an escaped bug and change failure rate?
Escaped bugs count individual defects customers found first. Change failure rate (a DORA metric) is the percentage of releases that caused a production failure needing remediation. Small teams can track both from the same log.
Should we write scripted tests or use exploratory testing?
Use both. Script the 3-5 most stable money paths so they run on every merge, and use exploratory checks, human or AI, to find problems scripts don't anticipate.
What makes a bug report actionable?
An actionable bug report includes steps to reproduce, expected result, actual result, environment and account state, and how often it reproduced from a clean start.
How long does it take to set up QA without a QA team?
About two weeks of part-time work: two days to pick journeys, two to write flows, three to four to script the stable ones, and the rest to start a checklist and rotation.
Who should own QA on a team with no QA engineer?
A rotating weekly QA owner, one engineer per week, who runs the checklist, triages reports, and can block a release.
Sources and further reading
- Software testing (Wikipedia)
- Exploratory testing (Wikipedia)
- Smoke testing (Wikipedia)
- Playwright documentation
- GitHub Actions documentation
- Google Cloud DORA, Accelerate State of DevOps Report 2024
- Stack Overflow Developer Survey 2025
- CISQ, The Cost of Poor Software Quality in the US: A 2022 Report
- NIST, The Economic Impacts of Inadequate Infrastructure for Software Testing (2002)
- Related BuildBetter guides: Test your app before every release with an AI QA agent, How to reproduce bugs with AI, AI exploratory testing vs. scripted E2E tests
Make churn optional.
Escaped bugs are churn you can measure. BuildBetter puts your QA Agent runs in the same workspace as the customer calls, tickets, and signals that tell you which journeys matter most, so you can test the money paths, file reproduced bugs, and ship the fix your customers asked for.