QA Testing Service

The shortcut: Most solo QA contractors chase one-off "test my app before launch" gigs and stay broke. The ones clearing $5K+ months sell a monthly retainer to small dev shops that have no in-house tester — and they own the Playwright suite.

Industry: Software & Tech | Investment level: Small — $2,000-$8,000 | Time to launch: 4-8 weeks (ISTQB study + Playwright suite samples + first retainer pitch gate the launch) Best for: Someone who's already done QA inside a product team — manual or automation — and wants to consult instead of carrying a Jira queue. You're a fit if you can write a Playwright test from scratch, file a bug report a developer doesn't roll their eyes at, and stay calm when a release goes sideways at 11 PM. What you'll likely make: $1,000-$2,500 month 3, $3,000-$5,000 month 6, $5,500-$9,000 month 12. Math is in Section 4.

Market Opportunity

It's 2pm on a Wednesday and checkout has been broken on Safari since 11am. Three customers already refunded. The eng team has been staring at it for an hour and can't reproduce it on Chrome. The CTO is on Slack. Nobody on the four-person team has QA in their job title — because a full-time QA engineer at $80K-$120K/year doesn't make sense at their size. So they don't hire — and the bugs keep going to production.

That gap is the wedge. Playwright adoption sits around 45% among QA professionals as of 2025-2026 (Playwright official site) and the framework hit 78,600+ GitHub stars. The tooling moat is gone — anyone with a laptop can stand up a real test suite. What dev teams don't have is the time to do it weekly.

The trap most new QA contractors fall into is selling time. They charge $50-$75/hour for manual testing of a finished build, get paid $1,200 for a week, then go find the next client. The ones who get past that ceiling sell fractional QA on retainer: $1,500-$3,500/month for ongoing coverage of a dev team's sprint cycle, with a Playwright suite they own. The retainer is the business. The pre-launch sprint is the lead magnet.

Launch With AI

Pro section. AI is the reason a solo QA contractor can credibly retain a 4-person dev team. It writes the first-pass test plan from the PRD, scaffolds the Playwright suite, formats every bug report into the shape your client's PM will actually triage, and drafts the monthly retainer memo. You spend the saved hours where AI cannot help: sitting in front of the actual product, hammering on the workflows that the PRD didn't describe, and catching the edge cases that production data made obvious only after launch.

The trap most first-year QA contractors fall into: they trust AI to find the bugs. AI generates Playwright tests that pass the happy path, miss the Safari-specific date picker bug, and silently report green while a real customer is rage-clicking checkout. AI is for the test-plan scaffolding, the boilerplate, the bug report formatting, and the retainer reports — but every flaky-test diagnosis, every accessibility check, every real-device pass, and every "is this actually a bug or intended behavior?" judgment call gets your eyes on it.

Important up-front: AI cannot tell you whether a feature is intuitive, sit on a real iPhone SE testing tap-target sizes, or have the conversation with your client's PM about whether shipping a Friday hotfix is worth the regression risk. It will also confidently generate Playwright selectors that pass once and break the next sprint when the dev renames a CSS class. You own every test-plan judgment, every accessibility verification, every real-device check, every staging-vs-production data decision; AI scales the writing and the scaffolding around them.

AI Tools You'll Use

Tool	Price	What it does
ChatGPT Plus	$20/mo	Test plan drafts, bug report formatting, sales follow-ups, retainer memos
Claude Pro	$20/mo	Long-context PRD-to-test-plan review, multi-screen flow analysis
Cursor + Copilot Business	$40-$60/mo	Playwright scaffold generation, fixture builders, page-object refactors
Allure Report (free)	$0	AI-friendly structured test output that you screenshot into bug reports
Loom AI	free	Bug walkthroughs with auto-titled chapters, retainer-month video summaries

The Workflow

PRD → test plan from sprint kickoff (Claude long-context, ~45 min/sprint). The first hour after sprint kickoff decides whether your retainer client thinks you're a $1,800/mo expense or a $3,000/mo lifeline. Paste the sprint PRD + the last 2 weeks of merged PRs into Claude:

"Below is the PRD for sprint [N] at [client, 4-person React/Node SaaS, B2B billing] plus the merged PR diffs since the last release. Generate the QA test plan: (a) every user-facing scenario (happy path + 2-3 critical edge cases per scenario), (b) the regression risks introduced by each PR (specifically: anywhere a shared component changed, anywhere an auth check moved, anywhere a Stripe webhook handler was touched), (c) the 5 cross-browser/cross-device checks that matter for THIS feature (not generic — name the specific Safari/iOS/Edge cases tied to what changed), (d) the 3 'don't bother testing' areas that are unrelated to this sprint, (e) the rough hours estimate by section. Tone: senior QA respectful of the client's deadline pressure. NEVER pad with low-value 'verify the page loads' filler."

Read every PR risk. The risks Claude misses are the ones a junior dev would miss too — that's where your eyes earn your retainer.
Playwright suite scaffolding (Cursor, ~90 min/critical flow). Once the test plan is approved, scaffold the suite. In Cursor, with the page source open:

"Generate a Playwright test file for the checkout flow at /checkout. Cover: (a) happy path — add to cart → fill address → fill card (use test card 4242...) → submit → verify success page URL, (b) declined card path — use test card 4000000000000002 → verify error message visible AND the cart is preserved, (c) 3DS challenge path — use test card 4000002500003155 → wait for challenge frame → simulate approval, (d) abandoned cart — fill address, navigate away, return → verify cart restored from localStorage, (e) tax calculation — verify tax line appears for CA/NY zip codes, absent for OR. Use page-object pattern (CheckoutPage class). Use data-testid selectors only — fail loudly if a test relies on a CSS class. Add explicit waits for network requests, NEVER setTimeout. Output the page object + the test file."

Verify every selector yourself. AI happily writes page.locator('.btn-primary-checkout-v2') — the kind of selector that breaks the second the dev renames the component.
Bug report formatting + Loom walkthrough (Cursor + Loom AI, ~10 min/bug). A well-formatted bug report saves the dev 20 minutes of triage. Paste the failing test output:

"Below is the Playwright failure trace for the checkout 3DS challenge test. Format as a Linear-ready bug report: (a) title (1 line, format: '[Severity] [Component]: what's broken'), (b) reproduction steps (numbered, copy-pasteable), (c) expected vs actual (1 line each), (d) environment (browser + version + OS + commit SHA), (e) attached evidence (Playwright trace link, screenshot file, console error), (f) suspected cause (one short hypothesis, NOT a fix), (g) priority justification (one sentence on customer impact). NEVER speculate beyond one hypothesis. NEVER write the fix."

Record a 60-second Loom showing the bug. Loom AI auto-titles + transcribes. The Loom is what stops the 'works on my machine' Slack debate — the dev sees the actual failure on their first morning coffee.
Cross-browser regression sweep summary (ChatGPT, ~30 min/sprint). End of every sprint, you run the full Playwright suite plus a manual cross-browser pass on BrowserStack. Paste the BrowserStack session links + Playwright Allure report:

"Below are the BrowserStack session links for Safari 17 / Edge / iOS Safari + the Allure report for sprint [N]. Generate the end-of-sprint regression memo: (a) total tests run, pass/fail count, flaky test count (with names), (b) cross-browser issues found (browser-specific, not general bugs), (c) accessibility findings from the manual axe-DevTools pass, (d) the 3 most important things the dev team needs to know before merging to main, (e) the 2 things I'd flag for next sprint's regression budget. Tone: senior QA in a 1-on-1 with the EM. Output as Notion-ready memo."

Every flaky test gets named. The 'I'll look into it later' flaky test is the one that masks a real production bug in week 6.
Monthly retainer report (ChatGPT, ~20 min/client/month). The retainer renews itself when the client sees a real-value memo, not just an invoice. Paste:

"I run the QA retainer for [client]. This month: (a) [N] sprints covered, (b) [N] bugs found pre-release ([breakdown by severity]), (c) [N] regressions caught by the Playwright smoke suite, (d) [N] flaky tests stabilized, (e) hours used [X] of [Y] retainer cap. Generate the 1-page client retainer report: (a) the dollar value of bugs caught pre-release (estimate the support hours / refund risk avoided), (b) Playwright suite uptime + coverage trend, (c) what I improved in the suite this month, (d) what I'm watching for next month (vendor SDK upgrades, browser releases), (e) one strategic recommendation. Tone: senior QA advisor. Output as Notion-ready 1-pager."

Send first business day of every month. The retainer's value isn't bugs found — it's the Friday-night-deploy confidence the client gets because you've been testing every PR.

Time Saved Per Week

Roughly 6-9 hours/week once your sprint kickoff template, Playwright scaffold prompt, and bug report format are dialed in:

PRD → test plan: 3 hours/sprint → 45 min (Claude long-context)
Playwright suite scaffolding: 4 hours/flow → 90 min (Cursor)
Bug report formatting: 25 min/bug → 10 min (ChatGPT + Loom AI)
Cross-browser regression memo: 90 min → 30 min (ChatGPT)
Monthly retainer report: 90 min/client → 20 min (ChatGPT template)

Trade that time for: 5 cold messages/week to dev EMs in your warm network, the second public Playwright case study, and the 2-hour real-device pass on iPhone SE + low-end Android that AI literally cannot do for you.

Total AI Stack Cost

Budget tier ($20/mo): ChatGPT Plus only. Cursor + Copilot have free tiers that cover the first 30 days while you build your first Playwright suite. Allure is free. Right for solo with one retainer.
Full tier ($80/mo): ChatGPT Plus + Claude Pro + Cursor + Copilot Business. Worth it the day you sign retainer 2 — Claude long-context on a full PRD + 30 PR diffs catches the regression risks ChatGPT misses.
Compare: A second QA contractor for sprint planning + Playwright scaffolding + retainer reports runs $4,000-$7,000/mo offshore. The full AI stack is one-hundredth that cost — and you keep eyes on every test before it ships.

Cancel anything you don't open in a 7-day window. Pay for Copilot Business specifically (not individual) — the IP indemnification matters when your retainer client's contract has the standard "no AI-generated code" clause and you need a one-line carve-out.

Your First Win

30 minutes from now your "is this a real retainer or a billable disaster" client filter is built. Open ChatGPT (free tier works). Paste:

"I'm a freelance QA contractor selling $1,800-$3,000/month retainers to small dev teams. Build me the 1-page client filter I run BEFORE signing any retainer: (a) the 8 questions I ask in the discovery call (Do you have a written PRD per sprint? — if no, scope a paid pre-launch sprint first. Is your CI green more than 90% of the time? — if no, the team has bigger problems than QA. Do PRs ship with tests already? — if zero, my retainer should be 50% test-suite buildout for the first 3 months. Are you OK with me filing bugs directly in your tracker? — if no, my hours bleed into Slack. Who decides bug priority? — if it's the CEO, expect 11pm Slack messages. Do you ship hotfixes on Fridays? — if yes, charge a 20% premium. Are you OK with my AI-tools-policy clause? — if no, walk. Is your prod data in your staging env? — if yes, that's a security finding I'll flag in week 1.), (b) the 4 'walk away' signals (refuses written SOW, expects me to write code fixes, requires my insurance to cover their negligence, wants 24/7 on-call without a paging budget), (c) the 1-paragraph 'thanks but this isn't a fit' email I send when the answer is no. Tone: senior QA, decisive."

Use the filter on every discovery call. Every retainer that ends in a fight started with a question I forgot to ask in week zero — this filter is worth more than your first 4 retainers combined.

Product / Service Offering

You're selling one core service in three shapes:

Pre-launch QA sprint — fixed-price, $800-$1,500. Execute a manual test plan against a build before release, file bugs in Linear or Jira, hand them a one-page summary. 3-5 days. This is how you get the first conversation.
Monthly QA retainer — $1,500-$3,500/month. Run regression on every sprint, maintain a Playwright smoke suite, file bugs as you find them, join standup once a week. This is the business.
Test-automation buildout — fixed-price $3,000-$8,000. Write the initial Playwright suite (auth flow, checkout, top 10 critical paths), wire it into GitHub Actions, document it. Often the on-ramp to the retainer.

Pick the retainer to anchor on. Pre-launch sprints convert to retainers about 20-30% of the time when you do good work. The buildout is highest-margin but takes a real sales cycle — clients don't buy a $5K project from someone they haven't worked with first.

Revenue Model

Unit economics for a solo QA contractor running mostly async, no employees, working from a laptop:

Service	Price	Variable cost (tools + payment fees)	Your time	Take-home per engagement
Pre-launch QA sprint	$1,200	$39 (BrowserStack month) + $35 (Stripe 2.9% + $0.30)	25-35 hrs	~$1,125
Monthly QA retainer (small)	$1,800/mo	$39 + $52	20-25 hrs/mo	~$1,700/mo
Monthly QA retainer (mid)	$2,800/mo	$39 + $81	30-35 hrs/mo	~$2,680/mo
Test-automation buildout	$5,000	$39 + $145	60-80 hrs	~$4,800
Bug-bash day (group session)	$750	$39 + $22	8 hrs	~$690

Your first $1K month = one pre-launch sprint at $1,200, take-home around $1,100. About a week of focused work. Your first $3K month = one mid retainer at $2,800 plus a $500 add-on bug bash, take-home around $3,150. Roughly 30-35 hours of work for the month, leaving room for a second client.

Two retainers at $2,500 each puts you at $5K/month gross on 50-55 hours of monthly work — the inflection point where most solo QA people either raise rates or add a second contractor. Stickiness is real: clients with a custom Playwright suite you built rarely churn inside 12 months because rebuilding the institutional knowledge of their app's edge cases costs them more than your fee.

Startup Costs

ISTQB Foundation Level cert (optional but legitimizes a solo founder fast): ~$200-$250 exam fee. Skip if you have 3+ years of in-house QA on your resume.
ISTQB Advanced Test Automation Engineer (worth it once you're focused on Playwright/Cypress retainers): additional ~$250.
Tooling stack: Playwright is free and open source. Cypress free for the OSS runner; Cypress Cloud paid if a client wants the dashboard. Postman free tier covers most API testing; Bruno is the open-source alternative.
Cross-browser coverage: BrowserStack at $39-$199/month. Run the $39 Live tier solo, add Automate (~$129/mo) once you have two retainers.
CI runner: GitHub Actions free tier gives 2,000 minutes/month — enough for one client's smoke suite. Heavier suites land closer to $150-$300/month in compute. Bill this as a pass-through.
Reporting + async video: Allure Report is free and integrates with Playwright and Cypress. Loom free tier covers most bug walkthroughs.
LLC + EIN + insurance: $35-$500 LLC filing depending on state — LLC University 50-state table. EIN is free at IRS EIN Online — never pay a third party. E&O for a solo software contractor runs $800-$2,000/year via Hiscox or Insureon.
Contracts: MSA + SOW templates from Bonsai or Fiverr Workspace. Pay an attorney $200-$500 to review your first MSA.

Realistic all-in: $2,000 if you skip the cert and self-write contracts; $8,000 if you sit both ISTQB exams, bind a year of E&O up front, and pre-pay BrowserStack Automate annually.

Legal & Formation

Business entity. Single-member LLC the day you sign your first SOW — separates your laptop and savings account from a "your test missed our checkout bug and we lost $40K" claim. Filing fee is $35-$500 by state — LLC University 50-state table. Get your EIN free at IRS EIN Online — services that charge $50-$300 are reselling a five-minute form. Once your net profit clears $80K-$100K/year, run the math on an S-corp election via IRS Form 2553. That's a year-two conversation, not year one.

Licenses & sales tax. No state license required to provide QA testing services. Custom QA work billed as professional services is generally not taxable in most states, but the line gets fuzzy if you bundle a hosted test-reporting dashboard or SaaS-style monitoring — at that point some states treat it as taxable software. State-by-state lookup at Avalara's SaaS sales tax tracker. Cross $100K in sales or 200 transactions in a single state and you have economic nexus there post-Wayfair.

Industry-specific risk. The trap that kills this business is E&O exposure when a bug ships to production after you tested. Your client launches, your Playwright suite passed, and three days later a customer hits a payment-flow bug your tests didn't cover. The client argues you missed it. Two protections, both required. Every SOW caps your liability at fees paid in the prior 12 months and defines deliverables as "test plans, test execution, and bug reports" — not "bug-free software" and not code fixes. And bind E&O ($800-$2,000/year) before your first retainer starts. Hiscox and Insureon both quote solo software contractors online in 10 minutes. If your client touches HIPAA-covered health data or maintains SOC 2, expect a vendor security questionnaire — synthetic test data only, never production PHI in staging.

Marketing & First Customers

Your first three retainer clients come from people who've already worked with you, not from cold outreach or Upwork. The order that actually works:

Direct outreach to your warm dev network. Text or DM 20 engineers, EMs, and CTOs you've worked with in the last three years. Pitch is one sentence: "I'm running fractional QA for small product teams — pre-launch sprints at $1,200 or monthly retainers from $1,800. Useful for your team, or know someone?" You'll close one to two clients off this list inside three weeks.
A public Playwright demo repo. Build a sample suite for a real public app, publish to GitHub, write a one-page case study. This is the link you send when a prospect asks what your work looks like. Sample suite beats resume.
Indie Hackers and Hacker News. Indie Hackers and HN's monthly "Ask HN: Who wants to be hired?" thread are real sources of dev-shop and small-startup leads. One thoughtful post about a real bug pattern beats 50 cold emails.
Upwork as a fallback, not a foundation. Upwork takes a flat 10% service fee and the QA category is full of $15/hour bidders. Use it to fill a gap month.

The retainer pitch lands easier after a paid pre-launch sprint. Go in for five days, find real bugs, write a Playwright smoke suite for the three flows that broke most, hand them a proposal for $1,800/month to maintain it. Conversion sits around 25-30% — much higher than cold-pitching the retainer.

First 90 Days

Week 1. File LLC. Get EIN. Set up a business bank account and Stripe.
Week 1-2. Build a public Playwright demo repo. Clean README, one real public app, cover auth + one critical flow. This is your portfolio.
Week 2-3. Bind E&O ($800-$2,000/year). Draft your MSA + SOW from a Bonsai template. Pay an attorney $200-$500 to review the MSA.
Week 3-4. Text 20 warm dev contacts. Pitch the pre-launch sprint at $1,200 or the retainer at $1,800/month. Aim for one paid sprint signed by end of week 4.
Week 4-6. Run the first pre-launch sprint. Deliver a one-page bug summary and a written retainer proposal on the last day. Capture a testimonial.
Week 6-8. Convert that client (or one warm referral) to a $1,800-$2,500/month retainer. Start the Playwright smoke suite and wire it into GitHub Actions.
Week 8-10. Post one case study to Indie Hackers or LinkedIn. Pitch a second pre-launch sprint to two more warm contacts. Don't lower the price.
Week 10-12. Sign a second retainer or land one more pre-launch sprint. Day-90 target: one retainer at $1,800-$2,500/month plus one active sprint, around $3,000-$3,500 gross for the month.

Common Pitfalls

Letting scope creep into "fix the bugs you found." Clients will quietly start asking you to patch the bugs, not just report them. A $2,000/month QA retainer is not a developer retainer. Spell it out in the SOW: deliverables are test plans, execution, and bug reports — not code commits. Offer an hourly bug-fix add-on if they want it.
Not budgeting test-suite maintenance into the retainer. Playwright tests break when the app's UI changes — new selectors, changed element IDs, API shape shifts. If you don't budget 4-6 hours every sprint for maintenance, the suite goes flaky inside 3 months and the client blames you. Build maintenance into the monthly hours from day one.
Skipping the contract and E&O on the first "small" gig. A $1,200 pre-launch sprint with no MSA and no insurance is the gig that ends with a client claiming you missed the bug that cost them a customer. Sign the MSA. Cap liability at fees paid. Bind E&O before client number one.
Underpricing the retainer to "get the client." A $900/month retainer is worse than no retainer — you'll resent the work by month two and ghost the client by month four. The floor is $1,500/month for a real dev team. If they can't afford that, sell a pre-launch sprint and walk.

Get your full launch plan — take the free 60-second quiz.