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

Change Order Desk

Turns a client's mid-project 'quick extra request' email thread into a priced, client-ready change order PDF for freelance web and design studios, so out-of-scope work gets billed instead of absorbed.

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.

Speculative6.47/10
MVP build (solo)
5 days
Launch price
$29
Sales to $1,000 revenue
35 customers
First paying customer
Direct one-to-one messages to studio owners sourced from public agency directories and scope-creep threads, opening with a free generated change order from their own redacted client thread.
Who pays

Owner or lead of a 1-10 person freelance web, design or dev studio (or solo freelancer billing roughly $75-$150/hr) in the US, UK, Canada or Australia, triggered the moment a client emails an extra request after the proposal is signed.

Biggest execution risk

Operational simplicity 5.3/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; 35 sales at $29 clears $1,000 of collected revenue; strongest signal is speed to first revenue at 8.4/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.

0/15
Entry price
$29
Solo build
5 days
30d base revenue
$496
30d profit†
$436
Section 1 of 8

Product opportunity and positioning

Target customer

Owner or lead of a 1-10 person freelance web, design or dev studio (or solo freelancer billing roughly $75-$150/hr) in the US, UK, Canada or Australia, triggered the moment a client emails an extra request after the proposal is signed.

Why now

Solo and micro-studio freelancing volume is high, generic chatbots cannot hold a per-project SOW diff or emit a signable document, and a single recovered change order pays for a year of the tool.

Problem

A client asks for one more page, another revision round or a small integration mid-project; the freelancer either absorbs 5-15 unbilled hours or loses an hour writing a change order and risking the relationship.

Solution

Paste the original proposal and the client thread; the tool extracts a numbered deliverable list, labels each new ask in-scope, ambiguous or out-of-scope with a cited clause, prices the out-of-scope work from a rate card, and outputs a one-page change order PDF plus a copy-ready approval email.

Differentiation · A general chatbot drafts prose; Change Order Desk holds the numbered deliverable list, runs the scope diff, applies hourly rate, minimum block and rush multiplier, and produces a one-page PDF with a signature block and validity date.

1. Product opportunity and positioning

Change Order Desk turns the most expensive email in a freelance studio's inbox into a billable artifact. A client asks for one more page, another revision round or a small integration after the proposal is signed. The freelancer absorbs 5-15 hours or loses an evening hand-writing a change order in Google Docs, and most absorb it. The friction is authoring, not awareness.

The workflow is two pastes. Paste the original proposal or SOW once; the tool extracts a numbered deliverable list and stores it per project. Paste the client thread; the tool extracts each distinct ask with its quoted sentence, then labels it in-scope, ambiguous or out-of-scope with a one-line rationale citing the matching deliverable. Out-of-scope items are priced from the user's rate card - hourly rate, minimum billing block, rush multiplier, currency - and the output is a one-page change order PDF with scope table, hours, unit price, total, validity date and signature block, plus a copy-ready client email requesting written approval.

The buyer is the owner or lead of a 1-10 person freelance web, design or dev studio billing $75-$150/hr in the US, UK, Canada or Australia. They approve $29-$99 without procurement, in the same minute the pain occurs, and they judge the product by one artifact rather than a demo.

A general chatbot can draft prose. It cannot hold a numbered deliverable list per project, run a diff against that list, apply a rate card and emit a signable document. The deliverable here is a PDF a client signs, not a paragraph a client reads.

JEV scored this concept 64.7/100 (band C). Its strongest criterion is speed to first revenue (8.44 normalized); its weakest is market demand (5.28). The plan below is a revenue test, not evidence of a large market.

Section 2 of 8

Smallest sellable MVP

One project, one pasted request thread, one unbranded one-page change order PDF plus the client approval email, unlocked after a $29 Stripe checkout.

Must-have features

  • Project setup that extracts and stores a numbered deliverable list from pasted proposal text
  • Request intake that extracts each distinct client ask with its quoted source sentence
  • Scope classifier returning in-scope, ambiguous or out-of-scope plus a rationale citing the matching deliverable
  • Rate card settings: hourly rate, minimum billing block, rush multiplier, currency
  • One-page change order PDF with scope table, hours, unit price, total, validity date and signature block
  • Client email generator with out-of-scope list, price and written-approval request
  • Stripe Checkout for $29 one-time and $49/$99 monthly, unlocking the unbranded PDF
  • Magic-link account with the last 20 projects stored
  • Watermarked free preview with a branded footer line on the client-facing PDF

Explicitly out of scope

  • SOW or proposal authoring
  • E-signature, invoicing, payments or time tracking
  • Slack, Jira, Linear or QuickBooks integrations
  • Client portal or two-sided workspace
  • Team roles and admin console beyond a single owner account
  • Multi-language PDFs beyond English in the first 30 days

Demo flow (what the buyer sees)

  1. Founder opens a project and pastes the client's redacted proposal text
  2. Tool returns a numbered deliverable list the user can edit
  3. User pastes the client's request thread
  4. Tool returns each ask labelled with a rationale quoting the matching deliverable
  5. User confirms rate card values: hourly rate, minimum 2h block, rush multiplier
  6. Tool renders a watermarked one-page change order PDF and the client email draft
  7. User pays $29 and downloads the unbranded PDF, then sends it to the client
Build plan

Technical implementation plan

Stack

Next.js on VercelSupabase Postgres with magic-link authOpenAI API with structured JSON outputreact-pdf for the one-page change orderStripe Checkout and Billing PortalResend for receipts and account emailsTailwind CSS

Architecture

A single Next.js app on Vercel holds the UI and server actions. Supabase stores users, projects, deliverable lists, extracted requests, rate cards and generated documents. Every generation call posts proposal text and thread text to a server route that prompts the LLM with a strict JSON schema, validates the response, prices the out-of-scope rows server-side with plain arithmetic (never the model), and stores the result. react-pdf renders the stored rows into a single-page PDF on demand; watermarked for free users, clean for paid orders verified by a Stripe webhook.

Build steps

  1. Create Supabase project, define tables for users, projects, deliverables, requests, rate_cards, documents and orders
  2. Deploy an empty Next.js app on Vercel and wire magic-link auth end to end
  3. Build the paste-proposal form and the extraction prompt returning a numbered deliverable array in JSON
  4. Build the paste-thread form and the ask-extraction prompt returning quoted asks in JSON
  5. Add the classifier prompt returning label, matched deliverable id and one-line rationale per ask
  6. Render the diff table in the UI with inline edit so users can override a label before pricing
  7. Implement the rate card form and server-side price arithmetic with minimum block and rush multiplier
  8. Build the react-pdf one-pager with scope table, totals, validity date and signature block
  9. Add Stripe Checkout for the $29 one-time tier and the $49/$99 subscriptions, plus the unlock webhook
  10. Add the watermark gate, the branded footer line and the free preview limit of one document
  11. Ship the client email generator that lists out-of-scope items, price and approval request
  12. Deploy, run five real proposals through it, and fix the two worst classification failures before outreach

AI components

  • Deliverable extraction from pasted proposal text
  • Ask extraction from pasted client thread with quoted sentences
  • Scope classification with rationale citing the matched deliverable
  • Client email drafting
  • All pricing arithmetic is deterministic server-side code, not model output
Hardest technical risk: Classification of messy, vague real-world proposals: a wrong out-of-scope call on a client-facing PDF damages the user's client relationship and triggers refunds.
Section 3 of 8

Pricing and monetization

Single Change Order

Entry offer
$29 one-time

For Freelancers with one live scope dispute who want to test the output

  • One unbranded change order PDF
  • Client email draft
  • Checkout only, no account required

Freelancer

$49 / month

For Solo freelancers who hit scope creep most months

  • Unlimited change orders
  • One rate card
  • Project history
  • Unbranded PDFs

Studio

$99 / month

For 2-10 person studios billing multiple clients

  • Three seats
  • Multiple rate cards and currencies
  • Saved proposal library
  • Priority generation queue

Model: One-time $29 per unbranded change order, with $49/month solo and $99/month studio subscriptions for repeat users.

First revenue offer: Send a redacted client thread and get one watermarked change order back free within a few hours; pay $29 to download it unbranded and send it today.

Expected ACV: $62

Upsell path: One-time $29 buyers are emailed the $49/month plan if they generate a second document; solo subscribers with two or more clients on file are pitched the $99 Studio tier with three seats.

Target customers
12
Revenue model
$1,188
Costs
$75
Profit model
$1,113
Section 4 of 8

First-customer acquisition

Primary channel

Direct one-to-one messages to studio owners sourced from public agency directories and scope-creep threads, opening with a free generated change order from their own redacted client thread.

Where to find them

  • Public freelance and agency directories listing 1-10 person web and design studios
  • r/freelance and r/webdev threads mentioning scope creep or unpaid revisions
  • Public portfolio sites advertising fixed-fee website packages
  • Design and dev community Slack groups with a freelance channel
  • Indie Hackers and freelancer Discord servers with a client-work channel
  • Referrals from each user, since the client who receives the PDF is also a business buyer

Exact outreach motions

  • Send 40 direct messages opening with the free-change-order offer and no pitch
  • Reply in three scope-creep threads with a specific change order example, linking the free generator
  • Deliver every free preview within four hours and note the exact dollar figure they should have billed
  • Follow up once, same day only if they replied, and never more than once
  • Ask each paid user for one referral to another studio owner after the PDF is delivered
  • Pitch the $99 Studio tier only to users who have generated two or more documents

Message template

Hi [name] - saw you take fixed-fee web projects. I built a tool that turns a scope-creep email into a priced change order PDF: it diffs the ask against your original proposal and bills it. Send me one redacted client thread and I'll generate yours free today. No signup needed.
Week-one goal: MVP live by day 5, 40 messages sent, 3 free previews delivered, 1 paid checkout attempted.
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

Auth and schema

  • Create Supabase tables for users, projects, deliverables, requests, rate_cards, documents and orders.
  • Deploy an empty Next.js app on Vercel with magic-link auth working end to end.

Deliverable: Deployed app with working login and empty project list.

Day 2Extraction

Proposal to numbered deliverables

  • Build the paste-proposal form.
  • Write the extraction prompt returning a JSON array of numbered deliverables.
  • Render an editable deliverable list per project.

Deliverable: A project holding an editable, numbered deliverable list.

Day 3Diff engine

Asks and classification

  • Build the paste-thread form and ask-extraction prompt with quoted sentences.
  • Add the classifier returning label, matched deliverable and one-line rationale.
  • Render the diff table with inline label override.

Deliverable: Scope diff table on screen with cited rationales.

Day 4Output

PDF and email

  • Build rate card settings: hourly rate, minimum block, rush multiplier, currency.
  • Compute prices server-side and render the one-page change order with react-pdf.
  • Add the client email generator.

Deliverable: Downloadable watermarked PDF plus email draft.

Day 5PaywallMVP shipped

Ship MVP

  • Add Stripe Checkout for $29 one-time and $49/$99 monthly.
  • Add the webhook that unlocks the unbranded PDF.
  • Enforce one free watermarked preview per account.
  • Deploy and run two real proposals through it.

Deliverable: Live MVP taking payments.

Day 6List building

250 targets

  • Compile 250 studio owners from public directories and portfolio sites into a spreadsheet.
  • Write the outreach message and a redacted sample thread for demos.

Deliverable: 250-row outreach list with contact routes.

Day 7First outreach

Send and post

  • Send 40 direct messages.
  • Post one specific change-order teardown in r/freelance.
  • Deliver every free preview the same day.

Deliverable: 40 messages sent, first previews delivered.

Week 2 · Launch & first sale · 7 days
Day 8Preview volume

More free artifacts

  • Send 50 messages.
  • Generate and return 3 free watermarked change orders.

Deliverable: 3 previews in client hands with dollar figures shown.

Day 9Accuracy pass

Fix classifier failures

  • Log every wrong label from previews.
  • Tighten the classifier prompt with two few-shot examples per failure type.

Deliverable: Revised classifier prompt deployed.

Day 10Proof content

Public example

  • Publish one real change order screenshot with the price visible in a scope-creep thread.
  • Send 40 messages.

Deliverable: Public example post live plus 40 messages sent.

Day 11Hook iteration

Reply rate

  • Rewrite the message opening for the bottom 20 non-repliers.
  • Send 40 messages with the new hook.

Deliverable: Two-hook comparison with reply counts.

Day 12First saleFirst sale target

Convert one preview

  • Offer $29 checkout to every warm preview recipient.
  • Verify checkout, webhook and unbranded download in production.
  • Deliver the paid PDF within two hours.

Deliverable: First collected payment.

Day 13Post-sale

Referral and proof

  • Ask the first buyer for one referral to another studio owner.
  • Ask for a two-sentence testimonial after they send the PDF.

Deliverable: Referral request sent, testimonial or decline logged.

Day 14Review

Funnel numbers

  • Tally messages sent, replies, previews, checkouts, revenue.
  • Decide whether the hook or the price is the constraint.

Deliverable: Written funnel tally and one decision.

Week 3 · Repeat & systematize · 7 days
Day 15Volume

More conversations

  • Send 50 messages to 2-10 person studios specifically.
  • Add the Studio tier seats and multi-currency option to checkout.

Deliverable: Studio tier live, 50 messages sent.

Day 16Free asset

Change-order template

  • Publish a free change-order PDF template page as a reply link in threads.
  • Link it to the generator with a preloaded example project.

Deliverable: Template page live and linked from outreach.

Day 17Referrals

User-driven leads

  • Email all users the referral ask.
  • Reply to two more scope-creep threads with a specific example.

Deliverable: Referral traffic and two public replies.

Day 18Quality

Messy proposals

  • Collect three deliberately vague proposals and test the classifier.
  • Add an ambiguous bucket rule requiring a user confirmation step before pricing.

Deliverable: Confirmation step for ambiguous items shipped.

Day 19Volume

Studios with teams

  • Send 50 messages to studios listing two or more staff.
  • Follow up once with day 12-15 non-repliers who opened.

Deliverable: 50 messages plus a follow-up batch.

Day 20Expansion

One-time to monthly

  • Email $29 buyers who generated a second document with the $49 plan.
  • Add the Billing Portal link to the account page.

Deliverable: Upgrade email sent, portal live.

Day 21Review

Mix and margin

  • Recompute revenue by tier and blended ARPU.
  • Decide whether to drop or keep the $29 entry tier.

Deliverable: Tier decision with revenue by tier.

Week 4 · Scale what works · 9 days
Day 22Volume

Final outreach wave

  • Send 50 messages with the best-performing hook.
  • Post a second public change-order example.

Deliverable: 50 messages sent, second post live.

Day 23Polish

Feedback fixes

  • Add a validity-date field and a rush multiplier display to the PDF.
  • Fix the two most-reported output problems.

Deliverable: Updated PDF template deployed.

Day 24Follow-up

Non-repliers

  • Send one final follow-up to all non-repliers.
  • Close or archive the outreach spreadsheet with per-lead status.

Deliverable: Clean pipeline with no open threads.

Day 25Studio push

High-value tier

  • Pitch $99 Studio to five warm leads with a sample multi-client rate card.
  • Offer a two-minute setup call to anyone who asks.

Deliverable: Five Studio pitches sent.

Day 26Risk

Refund and error handling

  • Add a visible assumption disclaimer to every generated PDF.
  • Log and review every user-corrected label for prompt fixes.

Deliverable: Disclaimer field shipped, correction log reviewed.

Day 27Proof

Testimonials

  • Collect three testimonials and publish only ones actually given.
  • Add social proof block to the landing page.

Deliverable: Landing page with verified testimonials.

Day 28Volume

Last push

  • Send 50 messages to a fresh list segment.
  • Push the $29 offer to every undecided preview recipient.

Deliverable: Final outreach batch and offer push sent.

Day 29Accounting

Real numbers

  • Reconcile Stripe payouts against revenue.
  • Compute true costs: API, hosting, domain, Stripe fees.
  • Record collected revenue and profit.

Deliverable: Revenue and profit statement for the 30 days.

Day 30Decision

Continue or stop

  • Write a post-mortem on what converted and what did not.
  • Set the next 30-day target from measured conversion, not the projection.

Deliverable: One-page post-mortem and go/no-go decision.

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

  • Roughly 5% of 250 targeted cold messages and community replies convert to any paid tier inside 30 days; this is a guess, not a measured rate
  • Scenario figures are projections, not verified revenue, existing customers or traction
  • Blended ARPU reflects a mix of $29 one-time, $49 monthly and $99 monthly purchases
  • Costs cover LLM API usage, Stripe fees, Vercel and domain only
  • No paid ads, no contractors, no inventory and no support staff are budgeted
  • Refunds are assumed to be netted inside ARPU rather than modelled separately

Conservative

3 customers
$147
collected revenue · avg payment $49
Refunds
n/a
Chargebacks
n/a
Payment fees
n/a
Paid marketing
n/a
Hackathon profit
n/a
Operating costs
n/a
Business profit
n/a

Pre-breakdown estimate. This report was generated before costs were itemised, so refunds, fees, ad spend and operating costs cannot be separated without inventing them. Nothing is estimated here. Original modelled profit (all costs included): $112.

Base case

8 customers
$496
collected revenue · avg payment $62
Refunds
n/a
Chargebacks
n/a
Payment fees
n/a
Paid marketing
n/a
Hackathon profit
n/a
Operating costs
n/a
Business profit
n/a

Pre-breakdown estimate. This report was generated before costs were itemised, so refunds, fees, ad spend and operating costs cannot be separated without inventing them. Nothing is estimated here. Original modelled profit (all costs included): $436.

Optimistic

20 customers
$1,400
collected revenue · avg payment $70
Refunds
n/a
Chargebacks
n/a
Payment fees
n/a
Paid marketing
n/a
Hackathon profit
n/a
Operating costs
n/a
Business profit
n/a

Pre-breakdown estimate. This report was generated before costs were itemised, so refunds, fees, ad spend and operating costs cannot be separated without inventing them. Nothing is estimated here. Original modelled profit (all costs included): $1,290.

Model your own numbers

Runs in your browser · nothing is saved
Collected revenue
$232
Payment fees (3.9%)
$9
Paid marketing
$0
Hackathon profit
$223
Business profit
$223

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.

Projection, not verified revenue. These are hypotheses for a 30-day solo test; no customers, sales or profit exist yet.

Section 7 of 8

Main risks and validation experiments

Risk 1Cold conversion lands far below 5% and revenue stays under $150.

Mitigation

Concentrate on warm channels where the founder returns a free artifact first, and keep the one-time $29 tier as the low-friction entry.

Validation experiment

Send 40 messages in 48 hours and count replies; anything under 3 replies means the hook, not the price, is wrong.

Kill criteria

Fewer than 2 replies from 100 messages and zero checkouts by day 14.

Risk 2The classifier makes wrong out-of-scope calls and users abandon after the first bad PDF.

Mitigation

Require user confirmation on ambiguous rows, expose inline label edits and add a visible assumption disclaimer to every PDF.

Validation experiment

Run five real proposals through the tool and count how many rows the user overrides before sending.

Kill criteria

Overrides above 30% of rows across five documents.

Risk 3Freelancers prefer informal change orders and will not pay for a formal PDF.

Mitigation

Show the recovered dollar amount in the free preview so the price is framed against the unbilled hours, not against the tool.

Validation experiment

Ask ten targets directly whether they sent a written change order in the last six months, and what happened.

Kill criteria

Eight of ten say they never send written change orders and never intend to.

Risk 4A general chatbot is good enough and the user skips the product.

Mitigation

Compete on the stored deliverable list, the rate-card arithmetic and the signature-ready one-page PDF, and keep the whole flow under two minutes.

Validation experiment

Ask three preview recipients what stopped them from doing this in ChatGPT, and record verbatim answers.

Kill criteria

All three name an unblockable reason that is not buildable in a week.

Risk 5Monthly subscribers churn after resolving a single dispute, so revenue never recurs.

Mitigation

Sell the $49 monthly plan as a per-project habit for users with two or more clients on file, and track second-document generation as the upgrade signal.

Validation experiment

Measure how many paid users generate a second document within seven days.

Kill criteria

Zero second documents across all paid users by day 25.

Section 8 of 8

Hour-by-hour: the first 24 hours

Hours 1-2

  • Freeze the feature list to the eight MVP items.
  • Create the Supabase project and define all tables.
  • Deploy an empty Next.js app to Vercel.

Output: Deployed skeleton with database schema.

Hours 3-5

  • Wire magic-link auth end to end.
  • Build the project creation form with proposal paste.
  • Write the deliverable extraction prompt returning JSON.

Output: A saved project showing a numbered deliverable list.

Hours 6-8

  • Build the client thread paste form.
  • Write the ask extraction prompt with quoted sentences.
  • Write the classifier prompt returning label, matched deliverable and rationale.

Output: Scope diff table rendering in the browser.

Hours 9-10

  • Build the rate card form.
  • Compute pricing server-side with minimum block and rush multiplier.
  • Render the one-page change order with react-pdf, watermarked.

Output: Downloadable watermarked change order PDF.

Hours 11-12

  • Add Stripe Checkout for $29 one-time and $49/$99 monthly.
  • Add the webhook that unlocks the unbranded PDF.
  • Commit the outreach list plan for day 6.

Output: Working paywall and a written outreach plan.

Complete report

Full 30-day launch report

Read the full generated report

Change Order Desk - 30-Day Solo Launch Report

1. Product opportunity and positioning

Change Order Desk turns the most expensive email in a freelance studio's inbox into a billable artifact. A client asks for one more page, another revision round or a small integration after the proposal is signed. The freelancer absorbs 5-15 unbilled hours or loses an evening hand-writing a change order in Google Docs, and most absorb it. The friction is authoring, not awareness.

The workflow is two pastes. Paste the original proposal once; the tool extracts and stores a numbered deliverable list for that project. Paste the client thread; the tool extracts each distinct ask with its quoted sentence and labels it in-scope, ambiguous or out-of-scope with a one-line rationale citing the matching deliverable. Out-of-scope items are priced from the rate card - hourly rate, minimum billing block, rush multiplier, currency - and the output is a one-page change order PDF with scope table, hours, unit price, total, validity date and signature block, plus a copy-ready client email requesting written approval.

The buyer is the owner or lead of a 1-10 person freelance web, design or dev studio billing $75-$150/hr in the US, UK, Canada or Australia. They approve $29-$99 without procurement, in the same minute the pain occurs, and they judge the product by one artifact rather than a demo.

A general chatbot drafts prose. It cannot hold a numbered deliverable list per project, run a diff against that list, apply a rate card and emit a signable document. The deliverable here is a PDF a client signs, not a paragraph a client reads.

JEV scored this concept 64.7/100 (band C). Its strongest criterion is speed to first revenue (8.44 normalized); its weakest is market demand (5.28). This plan is a revenue test, not evidence of a large market.

2. Smallest sellable MVP

The sellable unit is one project, one request thread, one unbranded change order PDF plus the client email. Nothing else earns money in week one.

The eight build items are: proposal paste and numbered deliverable extraction; thread paste and ask extraction with quoted sentences; the in-scope/ambiguous/out-of-scope classifier with a cited rationale; rate card settings; the one-page react-pdf change order; the client email generator; Stripe Checkout with a $29 one-time tier and $49/$99 monthly tiers; and magic-link accounts storing the last 20 projects. A single watermarked free preview is the trial; there is no other trial.

Explicitly out: SOW authoring, e-signature, invoicing, time tracking, Slack or Linear integrations, a client portal, team roles. Ship on day 5 and resist adding a dashboard beyond a project list.

3. Technical implementation plan

One Next.js app on Vercel, Supabase Postgres with magic-link auth, the OpenAI API with structured JSON output, react-pdf, Stripe Checkout and Billing Portal, and Resend for receipts.

Generation runs in a server route with a strict JSON schema and a validation step. The model extracts and classifies; it never prices. Hour totals, minimum billing blocks and rush multipliers are plain arithmetic in server code, so a hallucinated number cannot reach the PDF. Documents are stored as rows, and the PDF renders on demand - watermarked for free previews, clean after the Stripe webhook marks an order paid.

Build order: schema, auth, proposal extraction, thread extraction, classifier, diff table with inline override, rate card and pricing arithmetic, PDF render, Stripe, watermark gate, email generator, then five real proposals end to end.

The hardest technical risk is classifier accuracy on vague proposals. The mitigation is the ambiguous bucket plus a mandatory user confirmation before pricing, and a visible assumption line on every document.

4. Pricing and monetization

Three tiers, unchanged from the concept: $29 one-time for a single unbranded change order, $49/month for solo freelancers with unlimited documents and one rate card, $99/month for 2-10 person studios with three seats, multiple rate cards and a saved proposal library.

The one-time tier exists to remove the subscription objection in the first conversation. The upgrade signal is a second generated document: any $29 buyer who generates two gets the $49 plan offer the same day. Any $49 user with two or more clients on file gets the $99 Studio pitch. Blended ARPU in the scenarios is $49-$70, not the headline $99.

5. First-customer acquisition

The only channel is direct one-to-one outreach to studio owners, opening with a free generated change order from their own redacted thread. No ads, no SEO ramp, no partnerships.

Build a 250-row list from public agency directories and portfolio sites that advertise fixed-fee website or design packages, plus people posting about scope creep in freelance communities. The message is short: I built a tool that turns a scope-creep email into a priced change order PDF; send one redacted thread and I will generate yours free today.

Deliver every preview within four hours and state the dollar figure they should have billed on the live project. That number is the pitch. Reply in public scope-creep threads with a concrete example rather than a link-first pitch, and ask every paid user for one referral.

6. Thirty-day execution sequence

Days 1-5 are build only: schema and auth, proposal extraction, thread extraction and classification, PDF and email output, then Stripe and the watermark gate. The MVP must be live and taking payments on day 5.

Days 6-14 are the first revenue block: build the 250-row list, send 40-50 messages a day from day 7, deliver free previews same-day, fix the worst classifier failures on day 9, and convert a warm preview into a $29 checkout by day 12. Follow up once, never twice.

Days 15-21 repeat what worked at higher volume, add the Studio tier seats, publish a free change-order template as a reply link, tighten handling of ambiguous rows, and start upgrading one-time buyers to $49.

Days 22-30 are the last push plus honest accounting: final outreach wave, PDF polish, testimonial collection, Stripe reconciliation, and a go/no-go post-mortem written from measured conversion rather than the projection.

7. Revenue and profit scenarios

All three scenarios are projections, not verified revenue. No customers, sales or profit exist at the time of writing.

Conservative: 3 customers at a $49 blended ARPU gives $147 revenue, $35 costs, $112 profit. This is what a weak hook and a small list looks like.

Base: 8 customers at $62 blended ARPU gives $496 revenue, $60 costs, $436 profit. This assumes roughly 5% conversion on about 250 targeted touches, which is a guess.

Upside: 20 customers at $70 blended ARPU gives $1,400 revenue, $110 costs, $1,290 profit. That requires repeated public examples and referrals to work.

Costs are LLM API usage, Stripe fees, hosting and a domain. There are no salaries, ads or fixed commitments.

8. Main risks and validation experiments

The biggest risks, each tested cheaply this month. Cold conversion below 5%: test by sending 40 messages in 48 hours and counting replies; fewer than 2 replies per 100 messages means the hook is wrong. Classifier error on vague proposals: run five real proposals and count user overrides; above 30% of rows, stop and rewrite the prompt. Freelancers preferring informal change orders: ask ten targets whether they sent a written change order in six months; eight of ten saying never kills the wedge. Chatbot substitution: ask three preview recipients what stopped them from using ChatGPT and record it verbatim. Single-dispute churn: measure how many paid users generate a second document within seven days. Zero across all paid users by day 25 means the monthly tiers are wrong and the one-time tier should carry the product.

9. First 24 hours

Hours 1-2: freeze scope, create the Supabase schema, deploy an empty app. Hours 3-5: wire auth, build proposal paste, write the extraction prompt. Hours 6-8: thread paste, ask extraction, classifier with cited rationale. Hours 9-10: rate card form, deterministic pricing, watermarked PDF render. Hours 11-12: Stripe Checkout for all three tiers, unlock webhook, and a written outreach plan for day 6. By hour 12 the founder should be able to paste one real proposal and one real thread and hold a watermarked change order PDF.

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 →