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.
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.
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.
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.
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.
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)
- Founder or buyer opens the site and installs the read-only GitHub App or uploads a zip
- Repo picker selects one repo; pipeline downloads the tarball and runs deterministic scans
- Free preview page shows repo overview, LOC mix, dependency count and risk count
- Buyer clicks Unlock and pays $99 through Stripe Checkout
- Worker renders the 14-section PDF, JSON export and 30-day share link
- Resend emails the PDF and link; the artifact is also downloadable from the receipt page
Technical implementation plan
Stack
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
- Scaffold Next.js app, Supabase schema (jobs, repos, orders, artifacts) and deploy to a custom domain
- Register the GitHub App with read-only contents scope; build install callback and repo picker; add zip upload
- Write the worker: tarball fetch, cap on repo size and file count, file tree, LOC and language mix
- Add manifest parsing for npm/pip/composer/go, lockfile detection and license detection
- Add env-var inventory, regex + entropy secret scan, TODO/FIXME index, all emitting file:line
- Build the risk-register ranker: severity, evidence line, one-line remediation, max 12 items
- Render the 14-section template to PDF with React-PDF; add JSON export and signed share links
- Wire Stripe Checkout, webhook, free-preview gating and Resend delivery email
- Add LLM directory summaries with strict grounding and a visible sources line per summary
- 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
Pricing and monetization
Single Dossier
Entry offerFor 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
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
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.
First-customer acquisition
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]
30-day execution roadmap
Week 1 · Build & validate · 7 days
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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- Refunds
- $0
- Chargebacks
- $0
- Payment fees
- $12
- Paid marketing
- $0
- Hackathon profit
- $285
- Operating costs
- $25
- Business profit
- $260
Base case
10 customers- Refunds
- $0
- Chargebacks
- $0
- Payment fees
- $39
- Paid marketing
- $0
- Hackathon profit
- $951
- Operating costs
- $45
- Business profit
- $906
Optimistic
25 customers- 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.
Main risks and validation experiments
Risk 1Nobody pays $99 because the dev believes they can write the document themselves.
Lead every message with the finished sample PDF so the value is the output, not the idea; price against a billable hour.
Send 40 messages with the sample attached and count explicit price objections versus free-run requests.
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.
Ground every summary to the supplied file listing, print a sources line, and fall back to listing-only text on a failed check.
Run 5 real repos and have one dev check 10 summaries line by line against the files cited.
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.
Ship the zip-upload path in the same week and make it the default call to action on the landing page.
Compare install-started to analysis-started rate across the first 20 sessions.
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.
Hard cap on repo size and file count with an explicit message and a refund path.
Run the pipeline against 3 large public monorepos and time each stage.
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.
State non-goals on the checkout page above the pay button and repeat them in the delivery email.
Track refund reasons for every request in the first two weeks.
If refunds plus chargebacks cross 15% of orders, reposition the artifact or narrow the audience.
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
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 →ClientBrief Weekly
Turns a 60-second async check-in from each teammate into a branded, client-ready weekly status page and email draft for agency retainers, without anyone retyping last week's update.
Breakage Bill
Breakage Bill reads every saved question in a Metabase instance, matches them against a proposed column rename/drop, and produces a shareable report of exactly which dashboards and alerts break and who to warn.
CostClause
CostClause turns a Terraform plan or a 12-question stack form into a branded, client-signable monthly cloud cost estimate — low/expected/high ranges plus an assumptions-and-change-clause page — so small cloud agencies stop eating fixed-bid overages.