Growth: 16% per year. Bottom-up using an ARPA of $300 per repo per month ($3,600/yr), consistent with the idea's per-repo, CI-volume-tiered pricing plus a free CLI. TAM: roughly 350,000 organizations worldwide run substantial JS/TS automated test suites in CI (Jest alone exceeds ~20M weekly npm downloads, Vitest ~7M), and if each such team paid ~$3,600/yr that is ~$1.3B. SAM: the reachable, USD-transacting subset that are Jest/Vitest monorepo teams of 5-40 engineers with chronically flaky CI is ~70,000 teams x $3,600 = ~$250M. SOM: capturing ~0.25% of SAM (about 170 paying repos) over 18-24 months via free-CLI bottom-up seeding plus 3 written design partners yields ~$600k ARR, which is feasible for a solo founder at 20 hrs/week given the low $900 build cost and 16-week path to first revenue. IMPORTANT: live web search was rate-limited during this session, so the competitor pricing and market-size figures below are model-estimated from prior knowledge and MUST be re-verified against the linked vendor pages before you rely on them.

Differentiation: You win because the hard part of this product is your core skill, not a feature you bolt on: reproducing nondeterministic Jest/Vitest failures and reasoning about async handle leaks, cross-test global state, and ordering dependencies is exactly debugging depth, and incumbents (Trunk, BuildPulse, Datadog) stop at statistics. Narrowing to one stack lets your full-stack and API skills ship a CLI plus a read-only log-ingestion layer fast on a $900 budget, and every trial is self-proving: the report either reproduces the customer's flake deterministically and names the cause or it does not, so you sell verifiable outcomes instead of dashboards. Guard the main risk by scoping the paid promise to state/timer/ordering/handle-leak classes you can reproduce and being explicit about true external-race flakes.

Competitors

Customer segments

• Series A/B TypeScript SaaS scale-ups (15-40 engineers): Have a platform or DevEx team, a monorepo, and a flaky CI suite blocking merges; your highest-ARPA, security-review-capable buyers via the self-hostable log-upload mode.
• Seed-stage TS SaaS teams (5-15 engineers): No dedicated infra owner, so a single flake stalls everyone's deploys; land bottom-up through the free CLI and convert on first verified reproduction.
• Open-source TS / dev-tool maintainers: Run public CI with community-reported flakes and known failing test IDs; ideal for free-CLI adoption and shareable case studies that seed inbound.
• Platform/DevEx engineer champions inside larger orgs: Individuals who just lost a Friday bisecting a CI-only flake and will expense a per-repo plan, driving land-and-expand across additional repos.

Sources

• Trunk Flaky Tests (product and pricing): https://trunk.io/flaky-tests
• BuildPulse - Flaky test detection: https://buildpulse.io/
• Datadog Test Optimization: https://docs.datadoghq.com/tests/
• CircleCI - Test insights and flaky test detection: https://circleci.com/docs/insights-tests/
• Currents.dev - CI test analytics: https://currents.dev/
• Jest npm package (download volume as market proxy): https://www.npmjs.com/package/jest

The people who pay are platform/staff engineers and eng managers at 15-40 person TypeScript SaaS teams whose CI is chronically red from Jest/Vitest flakes; they buy now because a single flake just cost them a Friday and eroded team trust in the test suite.

Messaging angle: Hand us one failing test ID; get back a deterministic reproduction and a one-line fix, or you don't pay.

Pricing logic: $99/mo per repo (entry 'Core' tier) sits inside the SMB SaaS flat band ($29-199/mo) and directly undercuts BuildPulse's historical $50-150/mo range while charging per repo instead of per committer, which is how Trunk and Datadog price. For a 15-person team, $99/mo is trivially under one hour of a staff engineer's fully-loaded cost (~$120-150/hr), and one recovered flake-hunting Friday pays for a year. A higher $299/mo 'Scale' tier for high-CI-volume monorepos and a free CLI tier (local flake flagging only) seed bottom-up adoption; monthly projection assumes the $99 Core tier.

Funding: At a $900 startup cost against a $5,000 budget, self-fund entirely from personal savings and let paid manual pilots cover ongoing costs; do not raise outside money for a $900 requirement.

• Personal savings (staged): Deploy ~$900 of your $5,000 budget now, keeping ~$4,100 as runway for 12+ months of the $220/mo fixed costs plus insurance. The catch: this is your own capital at risk if reproduction fails on the flakes customers care about (your stated main risk), so validate with pilots before spending on infra scale.
• Revenue-first paid pilots: Charge 3 design partners a fixed $500 pilot fee to manually root-cause their worst flake before building (month 3 revenue line). Covers early hosting/AI credits and, more importantly, proves willingness to pay. The catch: manual pilots eat your 20h/week and do not scale, so cap them at 3 and convert to product fast.
• Pre-sold annual plans: Offer converted pilots an annual Core plan at 15-20% off ($990/yr vs $1,188) once the engine reproduces their flake. A few annual prepays fully cover the $2,600+ of year-one fixed costs. The catch: only sell annual after the product verifiably works on their tests, or you invite refund churn.

Assumptions

• Months 1-2 are pre-revenue: producing the 3 OSS case studies and DMing 20 platform/staff engineers; month 3's $500 is a one-off paid manual root-cause pilot from one design partner before the product exists.
• SaaS revenue starts month 4 at $99/repo/mo and grows to 35 paying repos by month 12; because reproduction runs automatically in CI, 35 repos is serviceable within 20h/week (support and false-positive triage, not per-repo labor).
• Gross margin holds near 80% despite AI inference and CI-compute costs by caching reproduction runs and capping LLM tokens per root-cause report; heavier usage tiers absorb the marginal compute.
• Free CLI tier converts to paid at ~3-5% and mainly functions as a distribution wedge, not a modeled revenue line.
• The verifiable-in-trial promise reproduces a meaningful majority of Jest/Vitest flakes (state leaks, unmocked timers, open handles, ordering); genuinely nondeterministic network/race flakes are flagged as 'likely cause' rather than deterministically reproduced.

FlakeRoot runs as a founder-led PLG SaaS: your week splits between building the reproduction engine against design-partner repos and doing manual root-cause work that doubles as validation. Once live, CI ingestion runs itself while you triage edge-case flakes the engine cannot yet crack.

Tool stack

Delivery workflow

1. Install: Engineer adds the FlakeRoot GitHub Action or runs the free CLI locally; it flags flaky test IDs from CI history.
2. Submit flake: They hand one failing test ID via CLI or dashboard; read-only log/artifact upload mode clears security review with no repo access.
3. Deterministic replay: A Firecracker worker re-runs the test in isolation, varies ordering/timers/global state, and forces the failure to reproduce.
4. Root-cause report: Engine classifies the cause (leaked global, unmocked timer, async handle leak, order dependency) and Claude renders a one-line fix + verified repro command.
5. Verify in trial: Buyer confirms the report reproduces their real flake before paying; this is the core PLG proof point.
6. Convert + bill: Stripe activates the per-repo monthly plan ($99-$499/mo by CI volume); CI ingestion runs continuously afterward.
7. Retain: Weekly digest of new flakes caught + fixed keeps the platform engineer seeing value; escalate unrepro'd cases to your manual queue.

Suppliers

Weekly time budget

• Building the repro/root-cause engine against partner repos: 9h/week
• Manual flake root-causing for design partners (validation + revenue): 4h/week
• Outbound: DMing staff/platform engineers, GitHub issue threads, case-study writing: 5h/week
• Admin: billing, security-review questionnaires, infra monitoring: 2h/week

20 hrs/week caps you at roughly 3-4 active design partners while manually backstopping flakes the engine cannot yet reproduce; that manual triage is the bottleneck. First thing to outsource once the engine reproduces >60% of submitted flakes automatically: the manual root-causing queue, hire a contract TypeScript engineer part-time so you stay on engine + distribution.

Positioning: For 5-40 engineer TypeScript SaaS teams, FlakeRoot is the SaaS flaky-test tool that deterministically reproduces one failing test and names its exact cause, unlike dashboards like Trunk or BuildPulse that only count flakes.

Name options

• FlakeRoot
• Determin
• Reflake
• RootCause CI
• Bisecta

Palette & voice

Logo concept (FR): A test-tube silhouette whose liquid line splits into a downward root fork, rendered in mint green (#3ddc97) on the dark background. The two roots subtly form an F and R. Use as a square app/CLI mark and a horizontal lockup with 'FlakeRoot' in a monospace-inflected sans.

Hypothesis: At least 3 of 20 platform/staff engineers on 15-40 person TypeScript SaaS teams with chronically flaky Jest/Vitest CI will pay a flat $500 pilot fee to hand over one failing test ID and receive a deterministically reproducible root cause plus a one-line fix within 5 business days. (budget $85)

Interview questions

1. Walk me through the last time a flaky test blocked a deploy or PR merge. What happened step by step?
2. How many hours did you or your team spend on flaky tests in the last month, and who did the work?
3. What did you actually do to diagnose that flake, from the moment CI went red?
4. Which tools or scripts are in your flaky-test workflow today, and what do they cost you monthly?
5. How do you decide whether to retry, skip, quarantine, or fix a flaky test?
6. When a test only fails in CI and passes locally, what have you tried to reproduce it?
7. Who on the team owns test reliability, and how is that time budgeted or justified to leadership?
8. The last time you gave up on a flake instead of fixing it, what made you stop?

Success criteria

• 3 or more design partners commit in writing to pay the $500 pilot fee.
• 6+ interviewed teams independently report losing 2+ engineer-hours/week to Jest/Vitest flakes.
• Landing page converts 5%+ of warm DM clicks into a booked call, plus 1+ cold-ad booking.

Kill criteria

• Fewer than 2 teams agree to the $500 pilot after 20 personalized DMs and 6+ interviews (demand too weak to justify a build).
• In the 3 manual case studies, you cannot deterministically reproduce 2+ of the flakes, confirming the core reproduction promise fails on real-world flakes.
• Interviewees consistently say flakes cost them under 1 hr/week or they already tolerate retries, meaning the pain is real but not a paid priority.

Founder-led outbound to platform/staff engineers who publicly complain about flaky Jest/Vitest suites, converted with a verifiable manual root-cause pilot, then compounded by open-source CLI adoption and technical case studies.

Path to 100: Because this is high-ticket and founder-led, target the first 10 paying clients before chasing 100 seats. Weeks 1-4 (inside your 20 hrs/week and $900 setup): publish the 3 verifiable case studies and ship the free CLI, then run daily outbound to flaky-test complainers, closing 3 paid $500 manual-repro pilots (first revenue by week 4-6, well ahead of the 16-week productized target). Weeks 5-10: convert 3 pilots into written design partners, build the ingestion+repro engine against their real failing tests, and let the CLI plus Show HN launch seed inbound trials, reaching clients 4-8. Weeks 11-16: spend $800 on one newsletter classified to reach cold TypeScript teams, publish new case studies from design-partner wins for compounding SEO, and move to per-repo pricing ($99-199/mo SMB flat, 15-20% annual discount) to cross 10 paying repos; only then scale paid and content to push from 10 clients toward 100 repos, keeping blended CAC under the $1500 B2B ceiling.

Entity: Single-member LLC formed in your home state (US assumed).. FlakeRoot ingests customer CI logs and possibly source snippets, so you want the liability shield an LLC gives between company obligations (a data-handling mistake, a breached SLA) and your personal assets. A per-repo SaaS with recurring revenue is worth the ~$100-300 formation cost from day one; a sole proprietorship exposes you personally. Bootstrapped and solo, so skip Delaware: form in the state where you live and work to avoid foreign-qualification fees and double filings. Upgrade when: Convert to a Delaware C-Corp only when you decide to raise a priced round from institutional VCs or bring on a co-founder with equity; that is the standard investors expect. Otherwise stay an LLC until first W-2 employee or ~$60-80k profit, when an S-corp tax election may cut self-employment tax (ask a CPA).

Setup steps

Licenses

Insurance

Contracts you’ll need

• Terms of Service (subscription agreement): Defines the per-repo subscription, acceptable use, uptime expectations, and liability caps for self-serve signups.
• Privacy Policy: Discloses what you collect from CI logs and how it is stored/retained; required before you ingest any customer data.
• Data Processing Addendum (DPA): Enterprise buyers' security reviews will demand this to cover how you process their code/log data; pair with your read-only, self-hostable CLI story.
• Design Partner / Pilot Agreement: For your 3 paid design partners: fixes the fee, scope of the manual root-cause work, confidentiality, and IP ownership of the engine you build.

Tax basics

• As a single-member LLC you are taxed as a sole proprietor by default: business profit flows to your personal return on Schedule C, so there is no separate federal entity tax.
• You owe self-employment tax (~15.3%) on net profit on top of income tax; set aside a portion of every Stripe payout for it.
• Once you expect to owe $1,000+ in tax, the IRS requires quarterly estimated payments (roughly April, June, September, January); missing them triggers penalties.
• Sales tax on SaaS depends entirely on the buyer's state, not yours: some states tax SaaS and some do not, and economic-nexus rules trigger collection once you pass a revenue/transaction threshold in that state. Consider a tool like Stripe Tax and check each state.
• Track deductible startup and operating costs from day one: LLC filing fees, your ~$900 startup spend, cloud/CI compute, Stripe fees, and software subscriptions are generally deductible against business income.