Score B · 6.69/10Free to read$100K Hackathon · November 16, 2026 → December 16, 2026Nov 15, 2026

Repo Handoff Dossier

A fixed 14-section PDF dossier generated from any GitHub repo in under 10 minutes, so a developer taking over an inherited codebase can hand the client a professional assessment instead of a two-day write-up.

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.

Promising6.69/10
MVP build (solo)
5 days
Launch price
$99
Sales to $1,000 revenue
11 customers
First paying customer
Cold email and DM to 200-400 freelance devs and 1-10 person shops whose public profiles advertise rescue, takeover or legacy-maintenance work.
Who pays

Solo freelance developers and 1-10 person dev shops (US/EU/India, billing in USD) who have just taken over a client's existing codebase and must produce an onboarding or handoff document within the first week.

Biggest execution risk

Operational simplicity 5.1/10

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; 11 sales at $99 clears $1,000 of collected revenue; strongest signal is speed to first revenue 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

10 concrete actions. Tick them off as you go — nothing is saved or sent.

0/10
Entry price
$99
Solo build
5 days
30d base revenue
$990
30d hackathon profit
$951
Section 1 of 8

Product opportunity and positioning

Target customer

Solo freelance developers and 1-10 person dev shops (US/EU/India, billing in USD) who have just taken over a client's existing codebase and must produce an onboarding or handoff document within the first week.

Why now

The trigger is already happening — a dev has just received an unfamiliar repo and a client is waiting — so no education, trust-building or procurement is required, and a $99 charge can be expensed to the engagement immediately.

Problem

Inheriting a repo means answering what it is, what is broken, what secrets are baked in, what dependencies are unmaintained and what finishing it costs — a 6-10 hour read that usually gets skipped, so the client relationship starts with a vague story.

Solution

Connect a repo read-only (GitHub App) or upload a zip; a deterministic pipeline maps files and LOC, parses dependency manifests, inventories env vars, scans for secrets, indexes TODO/FIXME and builds a ranked 8-12 item risk register with file:line evidence; a fixed 14-section template renders to PDF plus JSON and a shareable link.

Differentiation · The alternative is a senior dev's billable afternoon or nothing at all; this is a deterministic, evidence-cited artifact produced in minutes, not a platform, not a CI tool, and not an AI chat that guesses at behaviour.

1. Product opportunity and positioning

A freelance developer who takes over a client's codebase has roughly one week to explain what the code is, what is broken, and what finishing it will cost. Done properly that is 6-10 hours of file-by-file reading; done at all, it usually becomes a vague email. Repo Handoff Dossier compresses that into a deterministic static-analysis pipeline plus a fixed template: connect a repo, wait under ten minutes, receive a 14-section PDF with a file-tree and LOC map, dependency and license inventory, env-var inventory, secret-scan findings, a TODO/FIXME index, test-to-source ratio, CI and deploy config detection, and a ranked 8-12 item risk register where every item cites file:line and a one-line remediation.

The buyer is unambiguous and already in motion: a solo freelancer or 1-10 person shop in the US, EU or India, billing in USD, who has just won a rescue, maintenance or takeover engagement. There is no education step and no procurement cycle — the trigger is a repo in their inbox and a client expecting a document. The artifact is the pitch: a redacted sample dossier can be shown before any money changes hands, and $99 is expensed to the engagement the same day.

Positioned against the real alternatives — a billable afternoon or nothing at all — $99 for ten minutes is an easy yes. The concept is deliberately narrow: one document, one repo, one payment. It does not host repositories, does not run CI, does not fix code, and does not ask for a team account. That narrowness is what makes it buildable and sellable by one person in 30 days. JEV scored this concept 66.9/100 (band B), with speed-to-first-revenue as its strongest criterion and monetization potential as its weakest; the plan below compensates by forcing a paid link in front of a warm prospect by day 12 and by adding higher-priced tiers only after the first sale is banked.

Section 2 of 8

Smallest sellable MVP

A paid, self-serve page: paste a GitHub repo URL or upload a zip, get a free preview (repo overview, LOC mix, risk count), pay $99 via Stripe Checkout, and receive a 14-section PDF plus JSON and a 30-day share link by email.

Must-have features

  • Read-only GitHub App install with repo picker plus zip-upload fallback
  • Deterministic analyzer: file tree, language/LOC mix, dependency manifests (npm, pip, composer, go), lockfile presence, license detection
  • Env-var inventory, secret scan (regex + entropy) and TODO/FIXME index, all reported with file:line
  • Ranked 8-12 item risk register with file:line evidence and one-line remediation
  • Fixed 14-section React-PDF template, JSON export and expiring shareable read link
  • Stripe Checkout paywall with free preview unlocking the full artifact
  • Email delivery via Resend and a white-label cover option (logo + client name)

Explicitly out of scope

  • No code fixes, refactors, PRs or automated remediation
  • No continuous monitoring, CI integration or repo-change alerts
  • No GitLab or Bitbucket support in the first 30 days
  • No team seats, roles, audit log or SOC 2
  • No human review, consulting call or manual QA promise
  • No enterprise invoicing or security questionnaires

Demo flow (what the buyer sees)

  1. Founder or buyer opens the site and installs the read-only GitHub App or uploads a zip
  2. Repo picker selects one repo; pipeline downloads the tarball and runs deterministic scans
  3. Free preview page shows repo overview, LOC mix, dependency count and risk count
  4. Buyer clicks Unlock and pays $99 through Stripe Checkout
  5. Worker renders the 14-section PDF, JSON export and 30-day share link
  6. Resend emails the PDF and link; the artifact is also downloadable from the receipt page
Build plan

Technical implementation plan

Stack

Next.js on VercelOctokit + GitHub App (read-only contents scope)Supabase Postgres + object storageNode analysis worker on RailwayStripe CheckoutOpenAI API for grounded directory summariesReact-PDFResend

Architecture

The Next.js app on Vercel handles auth, the repo picker, the free-preview page and Stripe Checkout. On payment, it enqueues a job row in Supabase Postgres and calls the Railway worker. The worker fetches the repo tarball, runs the deterministic scanners (tree, LOC, manifests, env vars, secrets, TODOs, CI, license), builds the ranked risk register, then calls OpenAI once per top-level directory with only the file listing and exports as context. The rendered PDF and JSON go to Supabase object storage; the app serves a signed 30-day share link and Resend emails the artifacts.

Build steps

  1. Scaffold Next.js app, Supabase schema (jobs, repos, orders, artifacts) and deploy to a custom domain
  2. Register the GitHub App with read-only contents scope; build install callback and repo picker; add zip upload
  3. Write the worker: tarball fetch, cap on repo size and file count, file tree, LOC and language mix
  4. Add manifest parsing for npm/pip/composer/go, lockfile detection and license detection
  5. Add env-var inventory, regex + entropy secret scan, TODO/FIXME index, all emitting file:line
  6. Build the risk-register ranker: severity, evidence line, one-line remediation, max 12 items
  7. Render the 14-section template to PDF with React-PDF; add JSON export and signed share links
  8. Wire Stripe Checkout, webhook, free-preview gating and Resend delivery email
  9. Add LLM directory summaries with strict grounding and a visible sources line per summary
  10. Add white-label cover, generation priority for pack credits, and failure messaging for oversized repos

AI components

  • OpenAI call per top-level directory, fed only the file listing and exported symbols, producing a 2-3 sentence purpose summary
  • A grounding check that rejects any summary whose named files do not appear in the supplied listing
  • Optional plain-English executive summary page for the $249 Diligence tier, generated from the risk register JSON only
Hardest technical risk: LLM directory summaries drifting from the evidence and destroying credibility with a technical buyer; grounding must be limited to the file listing and exports, with a visible sources line and a hard fallback to listing-only text when the model output fails a token-match check.
Section 3 of 8

Pricing and monetization

Single Dossier

Entry offer
$99 one-time

For Freelance dev taking over one client codebase

  • 14-section PDF dossier for one repo
  • Ranked risk register with file:line evidence
  • JSON export
  • Shareable read-only link (30 days)

Diligence Dossier

$249 one-time

For Dev or non-technical founder assessing a codebase before committing budget

  • Everything in Single Dossier
  • Plain-English executive summary page
  • Dependency and license risk section
  • Remediation cost-band estimates
  • White-label cover with agency/client name

Agency 5-Pack

$399 one-time

For 1-10 person dev shop doing multiple takeovers per month

  • 5 dossier credits
  • White-label cover on every dossier
  • Shareable links per repo
  • Priority generation queue

Model: One-time purchase per repo, three fixed tiers, no subscription.

First revenue offer: Run your first dossier free on a repo you already hold, delivered within the hour, then $99 for the next one — link sent the same day.

Expected ACV: $99

Upsell path: Free-run users convert to $99 singles; shops doing more than one takeover a month move to the $399 five-pack; pre-purchase diligence buyers take the $249 tier with the executive summary and white-label cover.

Target customers
60
Revenue model
$5,940
Costs
$120
Profit model
$5,820
Section 4 of 8

First-customer acquisition

Primary channel

Cold email and DM to 200-400 freelance devs and 1-10 person shops whose public profiles advertise rescue, takeover or legacy-maintenance work.

Where to find them

  • Contra freelancer profiles filtered to web app rescue and maintenance
  • Upwork profiles with 'take over existing codebase' or 'legacy code' in the title
  • Clutch listings for 2-10 person development shops
  • X bios and pinned posts mentioning rescue work or inherited repos
  • Indie Hackers and r/webdev threads where someone describes a takeover in progress

Exact outreach motions

  • Send a 90-word email with a redacted sample dossier PDF attached and no ask beyond a reply
  • Offer a free dossier on a repo they already hold, delivered within the hour
  • Follow up at 48 hours with the $99 single-dossier checkout link
  • Post the sample dossier and the risk-register screenshot in r/webdev with the free-preview link
  • Reply in threads where a dev describes inheriting a repo, offering to run one free

Message template

Subject: the dossier for that repo you inherited

Hi [name] — saw you take on rescue/legacy codebases. When you pick up a repo you didn't write, you owe the client a written assessment, and that's usually half a day.

I built something that generates it: a 14-section PDF with a ranked risk register, every finding citing file:line, plus dependency, secret and TODO maps. Ten minutes from repo to document. Sample attached (client names redacted).

Want me to run it free on a repo you currently hold? I'll send it back within the hour — just want blunt feedback.

[founder]
Week-one goal: 120 qualified prospects listed with email or DM handle, 1 redacted sample dossier produced, and 40 messages sent with at least 3 free-run agreements.
Section 5 of 8

30-day execution roadmap

MVP deadline: day 5First sale target: day 1230 days planned
Week 1 · Build & validate · 7 days
Day 1Foundation

Deployable shell and payment rails

  • Scaffold Next.js app and deploy to a custom domain
  • Create Supabase tables for jobs, orders, artifacts
  • Connect Stripe and TrustMRR before any customer exists

Deliverable: Live domain with working sign-in shell and empty dashboard

Day 2Repo ingestion

Get a repo in, reliably

  • Register read-only GitHub App and build install callback
  • Build repo picker listing repos by recency
  • Ship zip-upload fallback for non-GitHub sources

Deliverable: Two working ingestion paths into a job row

Day 3Deterministic analyzer

Facts with file:line

  • Worker downloads tarball with size and file-count caps
  • Compute file tree, language and LOC mix
  • Parse npm/pip/composer/go manifests, lockfiles and licenses

Deliverable: Worker emits a structured analysis JSON for a real repo

Day 4Risk register

The part buyers pay for

  • Add env-var inventory and regex + entropy secret scan
  • Build TODO/FIXME index with file:line
  • Rank 8-12 risks with severity, evidence line and one-line remediation

Deliverable: Ranked risk register rendering correctly on 3 real repos

Day 5MVP liveMVP shipped

Paid artifact end to end

  • Render 14-section PDF with React-PDF plus JSON export
  • Gate full artifact behind Stripe Checkout, free preview stays open
  • Ship Resend delivery email and signed share link

Deliverable: Public site that takes $99 and emails a real dossier

Day 6Grounded summaries

LLM without hallucination

  • Call OpenAI per top-level directory with file listing only
  • Add grounding check rejecting unlisted file names
  • Print a sources line under every summary

Deliverable: Summaries with visible provenance or listing-only fallback

Day 7Sample and list

First 120 prospects

  • Generate a redacted sample dossier from a repo you hold
  • Build a 120-row prospect sheet with name, site, email/DM
  • List checkout page non-goals to pre-empt refunds

Deliverable: Sample PDF plus a 120-row outbound sheet

Week 2 · Launch & first sale · 7 days
Day 8QA on real repos

Fix what a buyer would notice

  • Run the pipeline on 5 varied public repos
  • Fix the 3 worst output failures
  • Tighten secret-scan severity rationale

Deliverable: 5 clean dossiers, fewer false positives

Day 9Outbound batch 1

40 first messages

  • Send 40 emails with the sample attached
  • Send 20 X or LinkedIn DMs to shops
  • Log every reply in the prospect sheet

Deliverable: 60 touches sent, replies tracked

Day 10Free runs

Deliver value before asking

  • Run free dossiers for every replier within the hour
  • Add white-label cover option while waiting
  • Ask each recipient for one blunt critique line

Deliverable: 3-6 free dossiers delivered and critiqued

Day 11Conversion polish

Remove checkout friction

  • Rewrite checkout page around the 14 sections and non-goals
  • Add a demo share link on the landing page
  • Test the full pay-to-delivery flow on a fresh account

Deliverable: Checkout page that converts a stranger

Day 12First sale sprintFirst sale target

Money in the window

  • Send 60 new messages plus 48-hour follow-ups with the $99 link
  • DM every free-run recipient their paid link
  • Publish one build-in-public post showing the sample

Deliverable: First paid dossier collected through TrustMRR

Day 13Community post

Channel that works without email

  • Post the sample dossier and risk-register screenshot in r/webdev
  • Reply to every comment within 2 hours
  • Offer a free run to anyone describing a takeover in progress

Deliverable: Community thread live with at least 5 replies

Day 14Week review

Cut what is not converting

  • Audit outreach reply rate by segment
  • Process any refund request manually and note the reason
  • Fix the single most-cited product complaint

Deliverable: Written week-2 verdict and fix list

Week 3 · Repeat & systematize · 7 days
Day 15Second channel

Indie Hackers and r/ExperiencedDevs

  • Publish a post on what the risk register catches in real repos
  • Send 60 new outbound messages
  • Follow up every non-replier from batch 1

Deliverable: Two community posts and 60 new touches

Day 16Diligence tier

Raise the ceiling

  • Add the plain-English executive summary page
  • Add dependency and license risk section
  • Ship the $249 checkout variant with white-label cover

Deliverable: $249 tier purchasable end to end

Day 17Outbound batch 3

Target pre-purchase diligence buyers

  • Message 40 founders and non-technical buyers assessing a codebase
  • Message 40 shops with 2+ takeover-capable profiles
  • Log tier interest per reply

Deliverable: 80 touches aimed at the $249 tier

Day 18Agency pack

Multi-repo buyers

  • Add 5-credit pack and credit ledger
  • Add priority queue flag for pack buyers
  • Ship per-repo share links on one receipt

Deliverable: $399 pack purchasable with credits tracked

Day 19Reliability

Do not fail in front of a buyer

  • Add explicit oversized-repo message with a size ceiling
  • Add Sentry error capture on the worker
  • Cache tarballs to cut repeated download cost

Deliverable: Graceful failure path and error visibility

Day 20Outbound batch 4

Volume with follow-ups

  • Send 60 messages with the $99 and $399 links
  • Follow up all day-9 and day-12 non-repliers
  • Update the sample with the best new finding

Deliverable: 180 cumulative touches logged

Day 21Referral loop

Buyers as a channel

  • Give every buyer one free dossier to pass to a peer
  • Add a shareable preview link to the delivery email
  • Ask two buyers for an anonymous one-line quote

Deliverable: Referral mechanic live, quotes collected

Week 4 · Scale what works · 7 days
Day 22Cost and books

Know the real numbers

  • Reconcile Stripe payouts against TrustMRR records
  • Measure per-dossier delivery cost across the month
  • Cut any LLM call that is not earning its cost

Deliverable: Cost-per-dossier figure and clean books

Day 23Outbound batch 5

Shops over solo devs

  • Send 80 messages to 2-10 person shops
  • Post the sample in one more community target
  • Reply to every inbound within 1 hour

Deliverable: 80 shop-targeted touches

Day 24Free-run conversion

Turn goodwill into revenue

  • Send every free-run user a $99 link with their own dossier referenced
  • Offer the pack to anyone who asked for a second repo
  • Log conversion rate from free to paid

Deliverable: Free-to-paid conversion number written down

Day 25Credibility page

Proof without inventing it

  • Publish only the anonymous quotes actually received
  • Show the 14-section list with a redacted example section
  • State non-goals and refund policy plainly

Deliverable: Landing page with real, cited quotes only

Day 26Outbound batch 6

Fill the final week

  • Send 80 messages with a week-end deadline angle
  • Follow up every unconverted replier
  • Escalate anyone requesting a sample repo run

Deliverable: Largest single outbound day logged

Day 27Pricing test

Find the real willingness to pay

  • Test $129 on new traffic against the $99 page
  • Measure checkout start-to-purchase rate
  • Keep the winner and record the delta

Deliverable: One pricing decision, evidence noted

Day 28Delivery day

Serve buyers fast

  • Clear the generation queue and priority items
  • Handle refunds manually within an hour
  • Fix any dossier with a wrong or unsupported claim

Deliverable: Zero outstanding jobs, refund rate recorded

Days 29-30 · Consolidate · 2 days
Day 29Final push

Convert the warm tail

  • Email every non-buyer with the Dec 16 cutoff
  • Post a final sample plus result summary
  • DM the five warmest prospects personally

Deliverable: Final outreach wave sent

Day 30Close and reconcile

Verified numbers only

  • Reconcile all revenue, refunds and fees against TrustMRR
  • Record verified profit and per-dossier cost
  • Write the next-30-day plan from actual buyer objections

Deliverable: Verified close-out sheet, no estimates

Section 6 of 8

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

  • Conservative: 3 paid dossiers, all on the $99 tier, from roughly 120 outbound messages and one community post.
  • Base: 10 paid dossiers, arpu held at $99 because tier mix stays single-tier early.
  • Upside: 25 paid dossiers, $99 blended arpu assumed even though some $249 and $399 sales would raise it.
  • Payment processing assumed at Stripe rates: 2.9% + $0.30, about 3.9% effective on a $99 charge.
  • Ad spend is zero in conservative and base because the channel is organic outreach and community posting; upside includes $150 of sponsored community posts.
  • Refunds assume zero in conservative and base; upside assumes one $99 refund on a wrong-claim complaint.
  • Operating costs cover Vercel, Railway worker, Supabase, domain and OpenAI tokens at under $0.60 per dossier delivered.
  • All three scenarios are projections from stated assumptions, not verified revenue or existing customers.

Conservative

3 customers
$297
collected revenue · avg payment $99
Refunds
$0
Chargebacks
$0
Payment fees
$12
Paid marketing
$0
Hackathon profit
$285
Operating costs
$25
Business profit
$260

Base case

10 customers
$990
collected revenue · avg payment $99
Refunds
$0
Chargebacks
$0
Payment fees
$39
Paid marketing
$0
Hackathon profit
$951
Operating costs
$45
Business profit
$906

Optimistic

25 customers
$2,475
collected revenue · avg payment $99
Refunds
$99
Chargebacks
$0
Payment fees
$97
Paid marketing
$150
Hackathon profit
$2,129
Operating costs
$90
Business profit
$2,039

Model your own numbers

Runs in your browser · nothing is saved
Collected revenue
$990
Payment fees (3.9%)
$39
Paid marketing
$0
Hackathon profit
$951
Business profit
$906

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. No customers, revenue or traction exist at launch; hackathon profit excludes hosting and delivery costs, business profit deducts them.

Section 7 of 8

Main risks and validation experiments

Risk 1Nobody pays $99 because the dev believes they can write the document themselves.

Mitigation

Lead every message with the finished sample PDF so the value is the output, not the idea; price against a billable hour.

Validation experiment

Send 40 messages with the sample attached and count explicit price objections versus free-run requests.

Kill criteria

If 60 messages produce zero paid unlocks and fewer than 5 free-run requests, the wedge is not painful enough.

Risk 2LLM directory summaries make a claim the repo does not support and the buyer demands a refund.

Mitigation

Ground every summary to the supplied file listing, print a sources line, and fall back to listing-only text on a failed check.

Validation experiment

Run 5 real repos and have one dev check 10 summaries line by line against the files cited.

Kill criteria

If more than 1 in 10 summaries is unsupported after grounding, remove the LLM layer and ship listing-only.

Risk 3GitHub App install friction stalls the free preview and kills the funnel.

Mitigation

Ship the zip-upload path in the same week and make it the default call to action on the landing page.

Validation experiment

Compare install-started to analysis-started rate across the first 20 sessions.

Kill criteria

If fewer than half of install-started sessions reach preview, promote zip upload to primary and defer the App.

Risk 4Large monorepos blow worker limits and produce silent failures in front of a paying buyer.

Mitigation

Hard cap on repo size and file count with an explicit message and a refund path.

Validation experiment

Run the pipeline against 3 large public monorepos and time each stage.

Kill criteria

If more than 20% of real targets exceed the cap, add a partial-analysis mode instead of raising limits.

Risk 5Buyers expect remediation rather than documentation and churn into refunds or chargebacks.

Mitigation

State non-goals on the checkout page above the pay button and repeat them in the delivery email.

Validation experiment

Track refund reasons for every request in the first two weeks.

Kill criteria

If refunds plus chargebacks cross 15% of orders, reposition the artifact or narrow the audience.

Section 8 of 8

Hour-by-hour: the first 24 hours

Hours 1-2

  • Create the repo, scaffold Next.js, deploy to Vercel on a new domain
  • Provision Supabase project and the jobs/orders/artifacts tables

Output: Live URL returning a working shell page

Hours 3-5

  • Open the Stripe account and connect it to TrustMRR before any customer exists
  • Draft the three tier prices in Stripe as test-mode products

Output: Payment account connected, products drafted in test mode

Hours 6-9

  • Register the read-only GitHub App and implement the install callback
  • Build the repo picker against the installation token

Output: A real repo selectable in the app

Hours 10-13

  • Write the worker skeleton: tarball download, size cap, file tree and LOC count
  • Deploy the worker to Railway and call it from the app

Output: First structured analysis JSON written to Supabase

Hours 14-16

  • Write the prospect sheet schema and add the first 30 targets
  • Draft the outreach message and the free-run offer

Output: 30-row prospect sheet plus a final outreach draft

Complete report

Full 30-day launch report

Read the full generated report

Repo Handoff Dossier — 30-Day Launch Report

JEV scored this concept 66.9/100 (band B). Strongest: speed to first revenue. Weakest: monetization and operational simplicity. Everything below is shaped by that: get a paid link in front of a warm prospect by day 12, and add higher tiers only after the first sale is banked. Revenue figures are projections, not traction.

1. Product opportunity and positioning

A freelance dev who inherits a client's codebase has about a week to explain what the code is, what is broken and what finishing it costs. Done properly that is 6-10 hours of reading; done at all, it is usually a vague email. Repo Handoff Dossier turns it into a deterministic static-analysis pipeline plus a fixed template: connect a repo, wait under ten minutes, get a 14-section PDF with a file-tree and LOC map, dependency and license inventory, env-var inventory, secret-scan findings, a TODO/FIXME index, test-to-source ratio, CI and deploy detection, and a ranked 8-12 item risk register citing file:line with a one-line remediation each.

The buyer is already in motion: a solo freelancer or 1-10 person shop in the US, EU or India, billing in USD, who just won a rescue, maintenance or takeover engagement. No education, no procurement — the trigger is a repo in their inbox and a client expecting a document. Positioned against a billable afternoon or nothing at all, $99 for ten minutes is an easy yes, and it gets expensed to the engagement.

The concept stays deliberately narrow: one document, one repo, one payment. No hosting, no CI, no remediation, no team seats. That narrowness is what one person can build and sell in 30 days.

2. Smallest sellable MVP

A public page where a stranger can pick one repo, see a free preview (overview, LOC mix, dependency count, risk count), pay $99 by card, and receive a 14-section PDF plus JSON and a 30-day share link by email. Five days of build. The risk register is the product; everything else is packaging. Zip upload ships alongside the GitHub App so install friction cannot block the funnel. Explicitly absent: code fixes, monitoring, GitLab support, team accounts, human review, enterprise paperwork.

3. Technical implementation plan

Next.js on Vercel serves the app, repo picker, preview and checkout. Payment writes an order row to Supabase and enqueues a job. A Node worker on Railway downloads the tarball, runs the deterministic scanners, builds the risk register, then calls OpenAI once per top-level directory with only the file listing and exports as context. PDF and JSON land in Supabase storage; Resend emails them; a signed link serves the shareable copy. The single hardest risk is the LLM layer inventing behaviour, so every summary carries a sources line and a grounding check rejects any output naming files outside the supplied listing, falling back to listing-only text.

4. Pricing and monetization

Three one-time tiers: Single Dossier $99, Diligence Dossier $249 (executive summary page, license risk, cost bands, white-label cover), Agency 5-Pack $399. No subscription — a per-repo artifact matches how the work arrives. Stripe takes roughly 3.9% effective. Delivery cost per dossier stays under $0.60 in tokens and compute, so no sale is below cost. The 5-pack exists because one takeover a month is a shop, not a hobby.

5. First-customer acquisition

The only channel that matters in week one is cold email and DM to devs whose public profiles advertise rescue, takeover or legacy-maintenance work, sourced from Contra, Upwork, Clutch and X bios. The message attaches a redacted sample dossier and offers to run the first one free on a repo they already hold, delivered within the hour. Follow up at 48 hours with the $99 link. Community posts in r/webdev, r/ExperiencedDevs and Indie Hackers exist as a parallel channel so deliverability problems cannot sink the launch.

6. 30-day execution roadmap

Days 1-5: build. Deployable shell and payment rails (day 1), ingestion with zip fallback (day 2), deterministic analyzer (day 3), risk register (day 4), paid PDF end to end (day 5). MVP deadline is day 5.

Days 6-9: grounded summaries, a redacted sample, a 120-row prospect sheet, and QA on five real repos to kill false positives before anyone sees output.

Days 10-14: free runs and outbound. 60 touches on day 9, free dossiers delivered within the hour, checkout page rewritten around the 14 sections, then a 60-message push with follow-ups on day 12 — first paid sale target. Community post on day 13, hard review on day 14.

Days 15-21: add surface area only after revenue exists. Second community channel, $249 tier, $399 credit pack, graceful oversized-repo handling, referral mechanic.

Days 22-30: reconcile books against TrustMRR, measure cost per dossier, more outbound, convert free-run users, publish only quotes actually received, one pricing test, a delivery-and-refund day, a final wave before the December 16 cutoff, and a verified close-out with no estimates left in it.

7. Revenue and profit scenarios

All three are projections. Conservative: 3 dossiers at $99, $297 gross, $12 fees, $25 operating. Base: 10 dossiers, $990 gross, $39 fees, $45 operating. Upside: 25 dossiers, $2,475 gross, one $99 refund, $97 fees, $150 of sponsored posts, $90 operating. Hackathon profit subtracts refunds, chargebacks, fees and ad spend only — hosting and tokens do not count against the contest. Business profit subtracts operating costs too. At this scale the difference is small; the point is not to confuse the two on any dashboard.

8. Main risks and validation experiments

Buyers may decide they can write the document themselves — tested by counting explicit price objections across 40 sample-led messages. LLM summaries may overreach — tested by line-checking 10 summaries against cited files. GitHub App friction may stall the funnel — tested by comparing install-started to preview-started sessions. Monorepos may break the worker — tested on three large public repos with a hard cap and a clear message. Buyers may expect remediation — tested by tracking refund reasons weekly. Each has a kill criterion in the JSON plan; the truthful one is that fewer than 5 free-run requests from 60 messages means the pain is not sharp enough.

9. First 24-hour action plan

Five blocks: deploy the shell (hours 1-2); connect Stripe to TrustMRR and draft tiers (3-5); register the GitHub App and repo picker (6-9); worker skeleton writing real analysis JSON (10-13); 30-row prospect sheet and final outreach draft (14-16). End state: a live URL, a connected payment account with zero customers, one repo parsing, and 30 names ready to message.

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 →