Linkpatch
Linkpatch crawls a company's public docs repo, proves which outbound links are dead, and opens one GitHub pull request that swaps each dead URL for a content-verified live replacement, so a docs owner clears a year of link rot in a single merge.
One product, one founder, thirty days. Everything below is built to be executed inside the contest window — the official rules still decide what counts.
Decide in 20 seconds
The facts that decide whether this is worth thirty days of yours.
Docs lead, DevRel engineer or OSS maintainer at a 20-500 person developer-tooling or API company whose documentation lives in a public GitHub repo in Markdown/MDX, triggered by a docs migration, rebrand, domain move, a wave of broken-link tickets, or a failing link-check CI job.
Market demand 4.5/10
Narrow the buyer to a segment with an urgent, already-budgeted problem and reference the specific trigger event that creates willingness to pay.
Why this could work in 30 days: one founder can ship the MVP in 5 days; the plan targets a first sale on day 12; 6 sales at $199 clears $1,000 of collected revenue; strongest signal is reachable customers at 8.1/10.
Score and projections come from the generated report and are not guarantees. The $100K Hackathon is run by Ship or Die — read the official rules before you build.
Your first 24 hours
15 concrete actions. Tick them off as you go — nothing is saved or sent.
Product opportunity and positioning
Target customer
Docs lead, DevRel engineer or OSS maintainer at a 20-500 person developer-tooling or API company whose documentation lives in a public GitHub repo in Markdown/MDX, triggered by a docs migration, rebrand, domain move, a wave of broken-link tickets, or a failing link-check CI job.
Why now
Wayback CDX plus cheap LLM scoring makes what-this-page-was and what-it-is-now answerable per link at under $2 per repo, so the repair can be shipped as a diff instead of a to-do list.
Problem
After every vendor rename or URL restructure, 60-300 outbound doc links return 404s; fixing them by hand means researching each target and editing files one at a time, so it never gets done and readers land on dead pages.
Solution
A five-stage pipeline: extract Markdown/MDX links with anchor text and context, verify with HTTP plus headless render and soft-404 detection, pull the last good Wayback snapshot, score replacements with an LLM against anchor text and snapshot title, then open one pull request with a per-link evidence table and a quarantine list.
Public documentation is a company's most-read sales asset and its least-maintained code. Every vendor rename, acquisition, domain move and docs-platform migration breaks outbound links; the CI link-check job turns red, someone opens an issue, and the work stalls because fixing 60-300 links by hand means researching each target and judging whether the new page carries the same content. The cost of the fix is not the edit. It is the research.
Linkpatch sells the research and the edit together. It runs a five-stage pipeline over a public GitHub docs repo - extract, verify, snapshot, replace, ship - and produces two artifacts: one pull request with per-file diffs, and one Linkpatch Report table listing dead URL, Wayback snapshot title, proposed replacement, confidence and one evidence line, plus a quarantine section for links it refused to guess at. The buyer reviews diffs instead of doing research.
The buyer is one person, not a committee: a docs lead, DevRel engineer or OSS maintainer at a 20-500 person developer-tooling company with Markdown/MDX docs in a public repo. The trigger is dated and public - a migration changelog, a rebrand, a wave of support tickets citing dead pages, or a failing lychee or markdown-link-check job. Because the repo is public, a real sample can be produced before a single word of sales copy is sent, and the deliverable costs the maintainer a merge review rather than a project.
Against free checkers the difference is the deliverable, not the detection: they print a list and hand the work back. Against a blind sed pass or an LLM rewriting URLs wholesale, the difference is evidence: nothing is proposed without a snapshot match and an explicit confidence score, and nothing ambiguous is merged.
This concept scored 60.6/100 in the JEV evaluation (band C, confidence 0.58). Its strongest criteria are reachable customers (8.1) and speed to first revenue (7.38); its weakest is market demand (4.48), with the explicit hint that the buyer should be narrowed to a segment with an urgent, already-budgeted problem and a named trigger event. The plan below is built around that hint. Every outreach action targets a repo with a live, dated, publicly visible failure, and the product stops at one mergeable diff rather than drifting into a docs platform, a CMS or a search product.
Smallest sellable MVP
A GitHub App that scans one public docs repo, verifies its outbound links, and opens one pull request containing content-verified replacements plus a report table - sold at $199 per repo through a Stripe payment link, with no account required to buy.
Must-have features
- GitHub App install with contents and pull_requests scope on one public repo
- Markdown/MDX extractor capturing URL, anchor text, heading and surrounding sentence
- HTTP verifier with redirect following, retries, headless render and soft-404 heuristic
- Wayback CDX snapshot lookup with cached title and excerpt per dead URL
- LLM replacement scorer returning up to three candidates with confidence and an evidence line
- 0.75 auto-accept threshold with everything below routed to quarantine
- Pull request writer with per-file diffs and the Linkpatch Report table in the PR body
- Quarantine CSV export plus Stripe payment link and emailed report
Explicitly out of scope
- Internal, private or SSO-gated link healing; no go/ namespace, no Slack app
- Site-wide SEO audit, content rewriting, page speed or accessibility scoring
- Dashboard, analytics product or user accounts in the first 30 days
- SOC 2, DPA, SSO or self-hosted deployment
- Non-GitHub hosts: GitLab, Bitbucket, Confluence, Notion
- Human concierge editing; every replacement must come from the pipeline
Demo flow (what the buyer sees)
- Buyer or founder installs the GitHub App on one public docs repo.
- Pipeline extracts every outbound http(s) link with anchor text and sentence context.
- Verifier marks each link OK, 404, redirect-chain or soft-404.
- Wayback CDX supplies the last good snapshot title for each dead URL.
- LLM proposes up to three replacements and justifies each against anchor text and snapshot title.
- Candidates above 0.75 are written to a branch; the rest go to quarantine.
- A pull request opens with diffs plus the Linkpatch Report table and quarantine CSV link.
Technical implementation plan
Stack
Architecture
A job row in Postgres drives a worker: clone or read the repo through Octokit, extract links, verify each URL with a cached HTTP plus render check, fetch Wayback snapshots only for confirmed-dead URLs, ask the model to justify up to three candidates per link, split results by the 0.75 threshold into replacements and quarantine, then commit a branch and open one PR whose body is the report table. Stripe webhooks create the job from a payment link; Vercel Cron re-queues paid repos weekly. Every stage writes to cache tables so a second scan of the same repo is cheap.
Build steps
- Scaffold Next.js app, Neon schema and Vercel deployment
- Build Markdown/MDX extractor with anchor text and sentence context
- Add HTTP verifier with redirect following, retries and timeouts
- Add headless render pass and soft-404 heuristic on 200 responses
- Integrate Wayback CDX snapshot lookup with per-run cache
- Build candidate search and LLM justification returning confidence plus evidence
- Add threshold split into replacement set and quarantine CSV
- Implement GitHub App install, branch, commit and PR creation
- Attach report table and quarantine section to the PR body
- Wire Stripe payment link and webhook to trigger a full sweep
- Add Resend report email and the weekly cron job
AI components
- LLM justification and 0-1 confidence scoring of candidate replacements against anchor text and Wayback snapshot title
- Similarity ranking of candidate URLs for the top-three shortlist
- Optional LLM soft-404 classifier on 200 responses containing not-found markers
Pricing and monetization
Repo Rescue
Entry offerFor Docs lead or maintainer with a current backlog of dead outbound links
- Full-repo outbound link verification with render and soft-404 detection
- One pull request with content-verified replacements
- Linkpatch Report table with confidence, evidence and snapshot reference
- Quarantine CSV of links the pipeline refused to guess at
Link Watch
For Same buyer after the first merge, who does not want the backlog to rebuild
- Weekly re-scan of the same repo
- New pull request only when new dead links appear
- Refreshed report comment with a running count of links fixed
Model: One-time $199 per repo for the backlog repair, then $49 per month for a weekly watcher that opens a PR only when new dead links appear.
First revenue offer: I opened a PR on your docs that fixes 47 dead outbound links and quarantines 9 I would not guess at. It is free to merge. If you want the full sweep across the rest of the docs site plus weekly monitoring, it is $199 one-time per repo or $49/month for the watcher.
Expected ACV: $199
Upsell path: After the first merge, sell the $49/month watcher on the same repo, then a second repo for teams running docs and handbook separately, then a multi-repo sweep at a per-repo discount.
First-customer acquisition
GitHub-native free sample: run Linkpatch on repos that already run a link checker or have an open broken-link issue, open a genuine free pull request, then message the maintainer with the PR link and the paid offer.
Where to find them
- GitHub code search for markdown-link-check, lychee, linkinator and mdbook-linkcheck config files
- Issues labelled broken link, dead link or link rot opened in the last 90 days on docs repos
- Public docs repos of 20-500 person developer-tooling and API companies with a commit in the last 30 days
- Migration changelogs and rebrand announcements that moved a docs domain
- Slack and Discord communities where docs maintainers and DevRel engineers gather
Exact outreach motions
- Run the pipeline on a repo and open a real free PR before any message is sent
- Message the maintainer with the PR link and the exact dead-link count
- Reply within two hours to any thread response and rebase the PR if asked
- Send the Stripe payment link directly in the thread, no demo call
- Follow up once five days later with the merge status, then stop after two touches
Message template
I opened a PR on your docs that fixes 47 dead outbound links and quarantines 9 I would not guess at. It is free to merge. If you want this every week across the whole docs site, it is $199 one-time per repo or $49/month for the watcher.
30-day execution roadmap
Week 1 · Build & validate · 7 days
Scaffold plus a target repo list
- Create the Next.js app on Vercel with a Neon schema for repos, links and runs.
- Write GitHub code search queries for markdown-link-check, lychee, linkinator and mdbook-linkcheck.
- Save 100 candidate repos with last-commit date and maintainer handle.
- Build the Markdown/MDX extractor for URL, anchor text, heading and sentence.
Deliverable: 100-row repo target list and a working local extractor.
HTTP checks and soft-404
- Add status checks with redirect following, timeouts and two retries.
- Add a headless render pass for JS-only pages.
- Add a soft-404 heuristic on 200 responses with not-found markers.
- Run the verifier on 5 repos and log dead-link counts.
Deliverable: Verified dead-link inventory for 5 repos.
Snapshots and replacement scoring
- Integrate Wayback CDX lookup and cache snapshot title and excerpt.
- Build candidate search from anchor text and snapshot title, top three results.
- Add the LLM justification call returning confidence and one evidence line.
- Set the 0.75 auto-accept threshold with everything below quarantined.
Deliverable: Replacement engine with threshold and quarantine output.
Pull request writer
- Add the GitHub App install flow with contents and pull_requests scope.
- Write branch creation, file rewrite and PR creation via Octokit.
- Render the Linkpatch Report table into the PR body.
- Append the quarantine section and CSV export link.
Deliverable: End-to-end run that opens a real PR on a test repo.
Stripe, email, MVP freeze
- Create the $199 Repo Rescue Stripe payment link on the TrustMRR-connected account.
- Add a webhook that records payment and queues a full sweep.
- Add Resend delivery of the report to the buyer email.
- Freeze scope: no dashboard, no accounts.
Deliverable: Working paid path from payment link to emailed report.
Accuracy pass
- Run the pipeline on 5 repos and grade 40 proposed replacements by hand.
- Fix the top failure mode found, likely redirect chains and moved domains.
- Record API and render cost per repo to test the $2 assumption.
- Select the 5 cleanest PRs to send first.
Deliverable: Accuracy and cost numbers plus 5 staged PRs.
Open the first free PRs
- Open 5 free PRs with full report bodies.
- Email or DM each maintainer with the PR link and a one-line offer.
- Log every send with a date in a follow-up table.
Deliverable: 5 free PRs live and 5 maintainers contacted.
Week 2 · Launch & first sale · 7 days
Next 15 free PRs
- Run the pipeline on 15 more repos from the saved list.
- Open 15 free PRs, skipping maintainers who already declined.
- Fix crashes on monorepos and very large link counts.
Deliverable: 20 free PRs open in total.
Message all 20 maintainers
- Send 20 personalised messages with the exact dead-link count.
- Post one free-audit offer in two maintainer communities.
- Reply to every response within two hours.
Deliverable: 20 messages sent and a response log started.
Handle replies
- Rebase or trim any PR that received review comments.
- Manually review quarantined links for responders who asked.
- Send the payment link to anyone asking about the full sweep.
Deliverable: Answer-ready PR threads and payment links sent.
Second touch
- Send one nudge on still-open PRs with the merge status.
- Run the pipeline on 10 new repos to keep the queue full.
- Draft the weekly watcher cron job.
Deliverable: Follow-ups sent and 10 new PRs staged.
First sale target
- Close the warmest thread with the $199 payment link.
- On payment, run the full-repo sweep immediately.
- Deliver the report within 24 hours and ask for a one-line quote.
Deliverable: First payment collected and delivered.
Second and third sale push
- Message all responders who have not paid with a merge-status nudge.
- Track time from payment to delivered report.
- Log every rejected replacement with its reason.
Deliverable: Delivery-time baseline and rejection log.
Week-two numbers
- Compute PRs opened, replies, merges, payments and conversion rate.
- Adjust the auto-accept threshold using the rejection log.
- Prune non-responding repos from the follow-up list.
Deliverable: Week-two funnel numbers and a tuned threshold.
Week 3 · Repeat & systematize · 7 days
Next 40 repos
- Refresh the repo list to 140 rows with new code-search queries.
- Filter to repos with a commit in the last 30 days.
- Queue 20 PRs for the next day.
Deliverable: 140-repo list with 20 queued runs.
20 more free PRs
- Open 20 free PRs from the refreshed list.
- Cap render spend per run and skip repos above 3,000 links.
Deliverable: 40 total PRs open across the campaign.
Message batch three
- Message 20 new maintainers with per-repo link counts.
- Post a second community offer with a sample report attached.
Deliverable: 40 maintainers contacted in total.
Weekly watcher
- Ship the cron re-scan for paid repos.
- Open a new PR only when new dead links appear, capped weekly.
- Add a running count of links fixed to the report comment.
Deliverable: Link Watch cron live on the first paid repo.
Sell Link Watch
- Offer the $49/month watcher to every paid customer.
- Offer it to any maintainer who merged a free PR.
Deliverable: Watcher offers sent to all paid or merged repos.
Second paid cohort
- Follow up on every unpaid payment link.
- Deliver any newly paid sweeps within 24 hours.
Deliverable: Updated paid-repo count and deliveries.
Cut cost per repo
- Measure API and render cost per repo across all runs.
- Add snapshot caching and skip links that passed in the last 7 days.
Deliverable: Documented cost per repo and a cheaper second run.
Week 4 · Scale what works · 7 days
Public sample report
- Publish one anonymised Linkpatch Report as a public example page.
- Link it from the landing page and from outreach messages.
Deliverable: Public sample report page live.
20 more PRs
- Open 20 free PRs from the refreshed list.
- Skip any repo whose maintainer already blocked or declined.
Deliverable: 60 total PRs opened.
Message batch four
- Message 20 new maintainers with their link counts.
- Re-target five repos where a PR merged but no payment followed.
Deliverable: 60 maintainers contacted in total.
Price test
- Test $199 against $149 on the next 10 threads.
- Keep the price that converts without extra objections.
Deliverable: Price decision backed by reply-to-payment data.
Support inbox
- Set up one shared inbox with canned replies for rejections and rebases.
- Document the manual fallback for repos the pipeline cannot parse.
Deliverable: Support runbook and inbox live.
Push toward base case
- Follow up with every warm thread one final time.
- Deliver all outstanding sweeps.
Deliverable: All open threads closed or parked.
Full funnel audit
- Tabulate PRs, merges, replies, payments, refunds and fees.
- Decide whether watcher renewals justify keeping the cron running.
Deliverable: Funnel audit and renewal decision.
Days 29-30 · Consolidate · 2 days
Last outbound wave
- Open 10 final PRs on the highest dead-link repos.
- Send a last-call message to every unpaid warm thread.
Deliverable: Final PR wave live and last-call messages sent.
Collect and submit
- Confirm all payments settled inside the contest window and issue any refunds.
- Export payment records for verification and submit the entry.
- Write a one-page post-mortem on what converted.
Deliverable: Submitted entry with payment records and post-mortem.
Revenue and profit scenarios
How the numbers are defined
Hackathon profit — Collected revenue − refunds − chargebacks − payment processing fees − paid marketing spend.
Business profit — Hackathon profit − operating costs (hosting, domains, tooling, AI/API delivery costs).
The contest ranks entrants on hackathon profit only. Hosting, tooling and AI/API delivery costs are not deducted by the organisers, but each sale still has to cover them — so we show both. Definitions verified on 2026-11-15 against the official rules.
Stated assumptions
- Base case assumes a blended ARPU of $199 because the 30-day window sells almost entirely one-time Repo Rescue; watcher subscriptions are upside, not base.
- Conservative: 3 paid repos from roughly 60 free PRs and 60 maintainer messages, a merge-to-payment rate near 10 percent.
- Base: 10 paid repos at $199, roughly double the conservative conversion with two paid cohorts in week two and week three.
- Upside: 24 paid repos, matching the concept monetization math, requiring several merges in week three to compound into referrals.
- Payment processing assumed at 4 percent blended (Stripe card plus international surcharge), applied to collected revenue.
- No paid marketing: all acquisition is organic GitHub outreach and free PRs, so ad_spend is zero in every scenario.
- Operating costs cover Vercel, Neon, domain, Resend and per-repo model and render spend at about $2 per served repo plus roughly $20-40 fixed.
- Refunds assumed at zero in conservative and base; upside carries one $199 refund.
- All figures are projections built from stated assumptions, not verified revenue, customers or traction.
Conservative
3 customers- Refunds
- $0
- Chargebacks
- $0
- Payment fees
- $24
- Paid marketing
- $0
- Hackathon profit
- $573
- Operating costs
- $25
- Business profit
- $548
Base case
10 customers- Refunds
- $0
- Chargebacks
- $0
- Payment fees
- $80
- Paid marketing
- $0
- Hackathon profit
- $1,910
- Operating costs
- $45
- Business profit
- $1,865
Optimistic
24 customers- Refunds
- $199
- Chargebacks
- $0
- Payment fees
- $191
- Paid marketing
- $0
- Hackathon profit
- $4,386
- Operating costs
- $90
- Business profit
- $4,296
Model your own numbers
Runs in your browser · nothing is saved- Collected revenue
- $1,990
- Payment fees (3.9%)
- $78
- Paid marketing
- $0
- Hackathon profit
- $1,912
- Business profit
- $1,867
Hypothetical arithmetic, not a forecast. The fee rate is a flat 3.9% assumption, refunds and chargebacks are left at zero here, and none of this is tracked data.
Scenario models from stated assumptions, not verified revenue.
Main risks and validation experiments
Risk 1Unsolicited pull requests read as spam and maintainers block or report the founder account, killing the acquisition loop.
One PR per repo, no tagging, personal message with the real count, immediate opt-out honoured and no re-send after two touches.
Open 10 free PRs in the first week and measure reply rate against block and report rate.
If more than 3 of the first 20 repos block or report, switch the channel to the concierge CSV audit with no unsolicited PRs.
Risk 2The model proposes a plausible but wrong replacement and the maintainer merges it, destroying trust faster than the free PR built it.
0.75 auto-accept threshold, one evidence line per proposal, and a quarantine list for anything below it.
Hand-grade 40 proposed replacements on 5 repos and record the accept rate before sending any PR.
If reviewers reject more than a third of proposed replacements, drop auto-accept and ship checker-only reports.
Risk 3Headless rendering every link blows the $2 per-repo cost assumption on large docs sites.
Cap at 3,000 links per run, cache snapshots, and skip links that passed in the last 7 days.
Measure actual API and render spend on the first 5 scanned repos.
If median cost exceeds $8 per repo, move to a per-link price or restrict rendering to suspected-404 URLs only.
Risk 4Maintainers merge the free PR and never pay, so conversion sits far below the assumed 10-25 percent.
Attach the $49 watcher and a full-site sweep offer directly in the PR thread, with one merge-status follow-up.
Track the merge-to-payment rate across the first 20 merges.
If merge-to-pay falls under 8 percent after 20 merges, stop free PRs and sell paid-only audits from a public sample instead.
Hour-by-hour: the first 24 hours
Hours 1-2
- Create the repo, deploy the Next.js skeleton to Vercel, provision Neon.
- Register the GitHub App shell and store credentials.
Output: Skeleton deployed with schema and app credentials committed.
Hours 3-5
- Build the Markdown/MDX extractor.
- Add the HTTP verifier with redirect following and soft-404 check.
- Run it on one real docs repo.
Output: Dead-link count for one real repo.
Hours 6-8
- Add Wayback CDX snapshot lookup.
- Add candidate search and the LLM justification call.
- Produce a ranked replacement table for that repo.
Output: Replacement table with confidence and evidence lines.
Hours 9-11
- Implement branch, commit and PR creation via Octokit.
- Embed the report table in the PR body.
- Open the first real PR on a repo found in code search.
Output: Live PR URL with the Linkpatch Report attached.
Hours 12-14
- Create the $199 Stripe payment link on the TrustMRR-connected account.
- Message the first maintainer with the PR link and the paid offer.
Output: Payment link live and first maintainer message sent.
Hours 15-18
- Build the 100-repo target list with the code-search queries.
- Queue the next 4 repos for tomorrow's runs.
Output: Repo target list saved, next 4 repos queued.
Full 30-day launch report
Read the full generated report
Linkpatch - 30-Day Public Report
1. Product opportunity and positioning
Public documentation is a company's most-read sales asset and its least-maintained code. Every vendor rename, acquisition, domain move and docs-platform migration breaks outbound links. The CI link-check job turns red, someone opens an issue, and the work stalls because fixing 60-300 links by hand means researching each target and judging whether the new page carries the same content. The cost of the fix is not the edit. It is the research.
Linkpatch sells the research and the edit together. It runs five stages over a public GitHub docs repo - extract, verify, snapshot, replace, ship - and produces two artifacts: one pull request with per-file diffs, and one Linkpatch Report table listing dead URL, Wayback snapshot title, proposed replacement, confidence and an evidence line, plus a quarantine section for links it refused to guess at. The buyer reviews diffs instead of doing research.
The buyer is one person, not a committee: a docs lead, DevRel engineer or OSS maintainer at a 20-500 person developer-tooling company with Markdown/MDX docs in a public repo. The trigger is dated and public - a migration changelog, a rebrand, a wave of support tickets citing dead pages, or a failing lychee job. Because the repo is public, a real sample exists before any sales copy is sent.
Against free checkers the difference is the deliverable, not the detection. Against a blind sed pass or an LLM rewriting URLs wholesale, the difference is evidence: nothing is proposed without a snapshot match and a confidence score, and nothing ambiguous is merged.
JEV scored this concept 60.6/100 (band C, confidence 0.58). Reachable customers (8.1) and speed to first revenue (7.38) are the strongest criteria; market demand (4.48) is the weakest, with the hint to narrow onto an urgent, already-budgeted problem with a named trigger. This plan is built on exactly that: every outreach action targets a repo with a live, publicly visible failure, and the product stops at one mergeable diff instead of becoming a docs platform.
2. Smallest sellable MVP
The sellable unit is one repo, one pull request, one price. In scope: a GitHub App that reads Markdown/MDX, an HTTP verifier with redirect following and a headless render pass, a soft-404 heuristic, a Wayback CDX snapshot lookup, an LLM-justified replacement scorer with a 0.75 threshold, a PR writer that embeds the report table, and a quarantine CSV. Payment is a Stripe payment link; delivery is the PR plus an emailed report. Out of scope for all 30 days: dashboards, accounts, private or SSO repos, non-GitHub hosts, SEO and content advice, and any human editing. The pipeline must produce every replacement, or delivery cost stops being near zero.
3. Technical implementation plan
Next.js on Vercel handles the landing page, the Stripe webhook and the cron. Octokit drives the GitHub App, Neon Postgres holds repos, runs, cache and quarantine rows, Cloudflare Browser Rendering handles JS-only and soft-404 checks, Wayback CDX supplies snapshots, an LLM API justifies candidates, Resend sends the report. A worker takes a repo, extracts links with anchor text and surrounding sentence, verifies each URL, fetches snapshots only for dead ones, asks the model for up to three justified candidates, splits results by the threshold, and commits a branch plus a PR. Cache rows make the second scan cheap.
The riskiest component is soft-404 and wrong-target matching: a page can return 200 with an error body, and a model can sound certain about the wrong page. The threshold and the quarantine are load-bearing. Build order: extractor, verifier, snapshot, scorer, PR writer, payment, email, watcher.
4. Pricing and monetization
Two lines only. Repo Rescue at $199 one-time clears the current backlog in a single merge. Link Watch at $49 per month re-scans weekly and opens a PR only when new dead links appear. Both sit under a typical company-card approval threshold, so a maintainer can buy without procurement. Serving one repo costs roughly $2 in model and render spend, so every sale clears its delivery cost by a wide margin and no sale is sold below cost. Revenue grows along one path: watcher on the same repo, then a second repo, then a multi-repo sweep.
5. First-customer acquisition
One channel, run hard: GitHub-native free sample. Day 1 produces a 100-repo list from code search for markdown-link-check, lychee, linkinator and mdbook-linkcheck configs, plus issues labelled broken link in the last 90 days. Days 6-8 run the pipeline and open 20 genuinely useful pull requests at no charge. Day 9 messages all 20 maintainers with the exact dead-link count, the PR link, and the $199 / $49 offer. Every response gets a reply within two hours and a Stripe link in the same thread. Follow-up is capped at two touches, five days apart, so the account stays clean. Week-one target: 20 PRs open and 20 maintainers messaged by day 9; first paid repo targeted for day 12.
6. Detailed 30-day execution roadmap
The contest window is Monday 16 November 2026 13:00 UTC to Wednesday 16 December 2026 13:00 UTC, and only money received inside it counts.
Days 1-5 (Nov 16-20) build: extractor, verifier with soft-404, Wayback snapshot layer, LLM scorer at a 0.75 threshold, PR writer with the report table, then Stripe and email. MVP freezes on day 5.
Days 6-11 (Nov 21-26) prove and contact: grade 40 replacements by hand, open the first 5 free PRs, reach 20 PRs, message 20 maintainers, handle replies and rebases.
Days 12-16 (Nov 27-Dec 1) convert: close the first paid repo on day 12, deliver within 24 hours, log rejections, tune the threshold, refresh the target list to 140 repos.
Days 17-21 (Dec 2-6) scale: 40 total PRs open, 40 maintainers contacted, watcher cron live, watcher offers sent, cost per repo measured and cut.
Days 22-28 (Dec 7-13) compound: public sample report, 60 PRs, a $199 vs $149 price test, support runbook, final follow-ups on every warm thread, full funnel audit.
Days 29-30 (Dec 14-16) close: final 10 PRs on the heaviest repos, last-call messages, confirm all payments settled inside the window, export records, submit, post-mortem.
7. Revenue and profit scenarios
All three scenarios are projections from stated assumptions, not verified revenue, customers or traction.
| Scenario | Paid repos | ARPU | Gross revenue | Fees (4%) | Refunds | Ad spend | Ops cost | Hackathon profit | Business profit |
|---|---|---|---|---|---|---|---|---|---|
| Conservative | 3 | $199 | $597 | $24 | $0 | $0 | $25 | $573 | $548 |
| Base | 10 | $199 | $1,990 | $80 | $0 | $0 | $45 | $1,910 | $1,865 |
| Upside | 24 | $199 | $4,776 | $191 | $199 | $0 | $90 | $4,386 | $4,296 |
Hackathon profit excludes hosting, tooling and model spend, which are counted only in business profit. Ad spend is zero in every case because acquisition is organic outreach. The conservative case lands near the low end the concept itself flagged as plausible; the upside case requires several merges in week three to turn into referrals.
8. Main risks and validation experiments
Spam perception. Unsolicited PRs can get the account blocked. Test: 10 free PRs, measure reply versus block rate. Kill signal: 3 blocks in the first 20 repos means switch to the concierge CSV audit.
Wrong replacement merged. Test: hand-grade 40 proposals, targeting an 80 percent accept rate. Kill signal: reviewers rejecting more than a third means shipping checker-only reports with no auto-accept.
Render cost blowout. Test: measure spend on the first 5 repos against the $2 assumption. Kill signal: median above $8 per repo means per-link pricing or rendering only suspected 404s.
Free merge, no payment. Test: track merge-to-payment across the first 20 merges. Kill signal: under 8 percent after 20 merges means stopping free PRs and selling paid audits from a public sample.
9. First 24-hour action plan
Hours 1-2: repo, Vercel deploy, Neon schema, GitHub App shell. Hours 3-5: extractor plus verifier, run on one real docs repo, get a dead-link count. Hours 6-8: Wayback snapshots, candidate search, LLM justification, produce a ranked replacement table. Hours 9-11: PR writer, open the first real PR with the report body. Hours 12-14: Stripe payment link live, message the first maintainer. Hours 15-18: build the 100-repo target list and queue the next four repos.
By the end of day one the founder has a deployed skeleton, one live pull request with a real report, one maintainer contacted, and a payment link that can accept money.
This brief was generated from public data about established startups, then narrowed and scored for a solo 30-day launch. Revenue and profit figures are scenario models, not verified results, guarantees or evidence of existing customers. Validate demand yourself before you spend a month on it — and check the contest rules for what counts toward your score.
Related ideas
All ideas →PitchSheet
PitchSheet turns your Google Sheet into a live, shareable proposal with auto-updating pricing and view analytics, so freelancers and agencies never send stale numbers again.
Call Receipt
Call Receipt turns a recorded client call into a branded, client-approvable scope receipt — decisions, commitments, and every out-of-scope request priced against the agency's own rate card — in about five minutes after the call ends.
WorkOrder Packet
A Slack-first intake that turns messy office requests into a vendor-ready Work Order Packet PDF with scope, access notes and a budget cap, plus a monthly cost-center ledger for the office manager.