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

GapKata Studio

GapKata Studio turns a working JavaScript snippet into a browser-based fill-in-the-gap coding exercise with auto-grading tests, hint ladder, and one embeddable HTML artifact for instructors.

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.

Speculative5.84/10
MVP build (solo)
5 days
Launch price
$29
Sales to $1,000 revenue
35 customers
First paying customer
Direct LinkedIn and X outreach to independent JavaScript bootcamp owners and lead instructors.
Who pays

Owner or lead instructor at a 1-10 person JavaScript/React bootcamp or corporate technical training firm, preparing a cohort and needing graded exercises this week; English-speaking, online.

Biggest execution risk

Market demand 4.1/10

Narrow the buyer to a segment with an urgent, already-budgeted problem and reference the specific trigger event that creates willingness to pay.

Why this could work in 30 days: one founder can ship the MVP in 5 days; the plan targets a first sale on day 12; 35 sales at $29 clears $1,000 of collected revenue; strongest signal is speed to first revenue at 8.5/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
$3,486
30d hackathon profit
$3,347
Section 1 of 8

Product opportunity and positioning

Target customer

Owner or lead instructor at a 1-10 person JavaScript/React bootcamp or corporate technical training firm, preparing a cohort and needing graded exercises this week; English-speaking, online.

Why now

JavaScript bootcamps and corporate trainers are preparing cohorts now, already hold solution code, and can judge a compiled sample in minutes without procurement or LMS approval.

Problem

Instructors already have working solution code, but turning it into a safe, auto-graded exercise with starter gaps, hidden tests, progressive hints, and a solution diff requires custom tooling or hours of lesson-prep.

Solution

The instructor pastes a working JavaScript snippet and learning objective; GapKata Studio parses the code, selects teachable AST nodes for blanks, generates starter code with TODOs, creates deterministic tests from examples plus instructor edits, adds a three-level hint ladder and solution diff, and publishes a static exercise page or downloadable single HTML bundle.

Differentiation · It builds from the instructor's own lesson code and exports a static graded artifact; generic katas do not match the lesson and LMS authoring tools are heavyweight.

1. Product opportunity and positioning

GapKata Studio is a narrow production tool for one buyer: the owner or lead instructor at a 1-10 person JavaScript/React bootcamp or corporate technical training firm. The buyer already has working solution code for a lesson and needs a graded exercise this week. The painful task is not writing the solution. It is converting that solution into starter code with teachable gaps, hidden tests, a three-level hint ladder, a safe browser runner, and an export the instructor can drop into class or an LMS. Generic katas do not match the lesson. LMS authoring tools are heavyweight and slow.

The wedge is a code-to-exercise compiler. The instructor pastes a JavaScript snippet and learning objective. GapKata Studio parses the code, selects teachable AST nodes for blanks, generates starter code with TODOs, proposes deterministic tests from examples plus instructor edits, drafts three hints and a solution diff, and publishes a hosted link or single HTML bundle. Students edit in the browser, run tests, and reveal hints. The instructor remains the final reviewer. This is deliberately not a learner course library, not a personalized tutorial engine, and not an LMS. It sells the artifact instructors already need: a graded exercise derived from their own code.

JEV scores the concept 58.4/100 in the C band. The strongest criterion is speed to first revenue; the weakest is market demand. The plan therefore does not assume broad demand or a platform pull. It sells a free compiled sample to a hand-built list, asks for one feedback item, and converts warm instructors to one-time packs. Defensibility is thin, so the 30-day edge is speed, sample quality, and repeat lesson-pack purchases rather than a platform story.

Why now: the buyer is reachable by direct message, can pay by card, and can judge the output in minutes. No marketplace cold-start, SEO ramp, procurement cycle, or integration approval is required. Pricing starts at $29 for one exercise, $99 for five, and $499 for 30. The commercial test is simple: can a solo founder turn 75 targeted conversations and a capped set of free samples into paid exercise packs inside 30 days? That is a projection, not verified demand. No customers, revenue, partnerships, or sources are claimed.

Section 2 of 8

Smallest sellable MVP

One instructor-supplied JavaScript snippet compiled into one editable exercise with starter gaps, deterministic tests, three hints, a gated solution diff, a hosted link, and a single HTML download.

Must-have features

  • Paste snippet, objective, difficulty, and target concept form
  • Babel AST gap selector for 2-6 teachable blanks
  • Starter code generation with TODO markers
  • Deterministic test harness generated from examples plus instructor edits
  • CodeMirror 6 student editor
  • Web Worker code execution with pass/fail test output
  • Three-level hint ladder and gated solution diff
  • Hosted exercise publish link
  • Single-file HTML bundle export
  • Stripe Payment Link checkout with access-token gating

Explicitly out of scope

  • Python, Java, or multi-language support
  • LMS, SCORM, or gradebook integration
  • Student accounts, cohort analytics, or classroom management
  • Video lessons or a course library
  • Enterprise SSO or procurement workflow
  • Live collaboration or code review chat
  • Marketplace of public exercises

Demo flow (what the buyer sees)

  1. Instructor pastes a working JavaScript snippet and learning objective
  2. Studio proposes teachable gaps and renders starter code with TODOs
  3. Instructor reviews and edits generated tests and hint text
  4. Studio builds a hosted exercise link and downloadable HTML bundle
  5. Student opens link, fills gaps in CodeMirror, and runs tests
  6. Runner returns pass/fail results and unlocks hints
  7. Instructor receives a ready exercise artifact for the lesson
Build plan

Technical implementation plan

Stack

Next.js on VercelTypeScriptSupabase PostgresBabel parser, traverse, and generatorCodeMirror 6Web Worker sandboxOpenAI API for test and hint suggestionsStripe Payment LinksStatic HTML export

Architecture

The app stores each exercise record and access token in Supabase. A server route parses the instructor snippet, proposes AST gaps, and drafts tests and hints. The instructor edits the exercise in a preview UI. Publishing renders a static exercise page and a single-file HTML bundle. The student runner executes code in a Web Worker with timeouts, no network access, and no secrets. Stripe Payment Links issue access tokens for paid packs.

Build steps

  1. Scaffold Next.js app and deploy blank Vercel shell
  2. Create exercise, test, hint, and access-token schema
  3. Build Babel parser route to select candidate AST gaps
  4. Generate starter code with masked TODO regions
  5. Implement deterministic test harness from examples
  6. Add CodeMirror editor and Web Worker runner
  7. Generate three hints and solution diff from original snippet
  8. Add hosted publish page and HTML bundle export
  9. Wire Stripe Payment Link and token-gated access
  10. Run end-to-end sample, fix top issues, and deploy

AI components

  • Classify teachable AST nodes and suggest blank selection
  • Draft deterministic tests from sample calls and expected outputs
  • Write three-level hint text and solution explanation
  • Summarize learning objective into exercise metadata
Hardest technical risk: Generated tests will be brittle on arbitrary instructor snippets, causing false failures and rejection of the artifact.
Section 3 of 8

Pricing and monetization

Single Exercise

Entry offer
$29 one-time

For Instructor testing one lesson

  • 1 generated exercise
  • editable tests and hints
  • hosted link and HTML export

Lesson Pack

$99 one-time

For Instructor preparing a module

  • 5 exercises
  • custom exercise titles
  • offline HTML exports

Studio Pack

$499 one-time

For Small bootcamp or corporate trainer preparing a cohort

  • 30 exercises
  • priority generation
  • custom pass thresholds and solution diffs
  • offline HTML bundles for LMS use

Model: One-time exercise packs with repeat cohort and module purchases, not a subscription.

First revenue offer: I will compile one of your existing lesson solutions into a free graded exercise within 24 hours; if it fits, the Lesson Pack is $99 for five exercises.

Expected ACV: $249

Upsell path: Start with a free sample, convert to a $99 Lesson Pack, then upgrade to a $499 Studio Pack when the instructor needs a full cohort; repeat with each new module or cohort.

Target customers
40
Revenue model
$19,960
Costs
$750
Profit model
$19,210
Section 4 of 8

First-customer acquisition

Primary channel

Direct LinkedIn and X outreach to independent JavaScript bootcamp owners and lead instructors.

Where to find them

  • LinkedIn search for JavaScript bootcamp owner
  • LinkedIn search for lead instructor React bootcamp
  • Small bootcamp team and about pages
  • X search for instructors posting about teaching JavaScript cohorts
  • Corporate technical training pages listing lead trainers
  • Founder and instructor newsletters where small bootcamps are mentioned

Exact outreach motions

  • Build a 75-lead spreadsheet with name, role, bootcamp, cohort timing, and public lesson evidence
  • Send 20-25 short DMs per day offering one free compiled sample from an existing lesson solution
  • Deliver each accepted sample within 24 hours and ask for one concrete feedback item
  • Follow up after 48 hours with the offline HTML export option for LMS use
  • Offer the $99 Lesson Pack first and the $499 Studio Pack only after sample acceptance

Message template

Hi [Name] - I am building GapKata Studio for JS/React instructors. I will turn one of your existing lesson solutions into a graded browser exercise with tests and hints, free, within 24 hours. Want me to do one? No call needed.
Week-one goal: 75 qualified leads listed, 40 DMs sent, 6 sample acceptances, and 2 paid-pack conversations.
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 1Build

Scaffold and gap parser

  • Create Next.js and TypeScript repo
  • Define exercise and access-token schema
  • Wire Babel parser to select AST gaps
  • Render starter code with masked TODOs

Deliverable: Deployed shell and parser prototype

Day 2Build

Generator and instructor form

  • Build snippet, objective, and difficulty form
  • Generate starter code and exercise record
  • Add test proposal from sample calls
  • Add basic instructor preview

Deliverable: Working generation form and preview

Day 3Build

Browser runner

  • Add CodeMirror 6 editor
  • Run student code in Web Worker
  • Implement deterministic test harness
  • Show pass/fail results and errors

Deliverable: Student exercise runner

Day 4Build

Hints, export, and checkout

  • Generate three-level hint ladder
  • Add gated solution diff
  • Build hosted publish page
  • Add Stripe Payment Link and token gate

Deliverable: Paid sample path with hosted and export output

Day 5BuildMVP shipped

End-to-end MVP

  • Compile one founder snippet end to end
  • Test HTML bundle export
  • Fix top blockers and deploy
  • Write 10-minute sample delivery checklist

Deliverable: Sellable MVP live by MVP deadline

Day 6Launch

Lead list and offer page

  • Build 75-lead instructor list
  • Write free sample offer page
  • Create sample request form
  • Prepare DM tracking sheet

Deliverable: Lead list and sample offer live

Day 7Launch

First outreach wave

  • Send 25 targeted DMs
  • Post one sample offer on X and LinkedIn
  • Log replies and objections
  • Schedule sample delivery slots

Deliverable: 25 DMs sent and replies logged

Week 2 · Launch & first sale · 7 days
Day 8Sell

Deliver free samples

  • Compile 2-4 accepted samples
  • Ask for one concrete feedback item
  • Track minutes per sample
  • Fix one recurring issue

Deliverable: Samples delivered and feedback captured

Day 9Sell

Follow-up and iterate

  • Follow up all 48-hour-old samples
  • Fix top rejection reason
  • Add missing hint editing control
  • Update DM angle from objections

Deliverable: Improved generator and follow-ups sent

Day 10Sell

Test and hint editing

  • Add instructor test editing UI
  • Add hint text editing
  • Add exercise title and pass threshold
  • Retest one sample

Deliverable: Editable exercise artifact

Day 11Sell

Second outreach wave

  • Send 40 targeted DMs
  • Ask warm replies for sample requests
  • Publish one anonymized sample exercise
  • Log lead source quality

Deliverable: 40 DMs sent and second sample queue

Day 12SellFirst sale target

First sale target

  • Send Stripe link to warm sample recipients
  • Close first paid pack
  • Deliver first paid exercise or pack
  • Record exact fulfillment steps

Deliverable: First paying customer and delivery record

Day 13Sell

Fulfill paid pack

  • Generate paid exercises
  • Review tests and hints manually
  • Export HTML bundles
  • Send access links and receipt

Deliverable: Paid pack delivered

Day 14Sell

Conversion review

  • Calculate DMs to samples to sales
  • Identify best-performing lead segment
  • Rewrite message for low-reply segment
  • Set next week sample cap

Deliverable: Conversion review and revised script

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

Bootcamp owner wave

  • Send 30 DMs to bootcamp owners
  • Target cohort-start timing
  • Offer one free sample per owner
  • Track accepted samples

Deliverable: Bootcamp owner pipeline

Day 16Scale

Corporate trainers

  • Build 25 corporate trainer leads
  • Send 15 tailored DMs
  • Offer offline HTML for LMS use
  • Log approval friction

Deliverable: Corporate trainer pipeline

Day 17Scale

Repeat purchase offer

  • Add cohort refresh offer copy
  • Ask first buyer about next module
  • Create 5-exercise repeat pack outline
  • Add repeat purchase note to site

Deliverable: Repeat offer ready

Day 18Scale

HTML export for LMS

  • Improve single-file bundle
  • Add exercise title and instructions
  • Test export in a clean browser
  • Document LMS upload steps

Deliverable: LMS-ready HTML bundle

Day 19Scale

Sandbox hardening

  • Add execution timeout
  • Block network access paths
  • Test infinite loop and error cases
  • Remove secrets from runner

Deliverable: Safer browser runner

Day 20Scale

Sample follow-ups

  • Follow up all unconverted samples
  • Ask for paid pack decision
  • Offer $99 Lesson Pack
  • Log rejection reasons

Deliverable: Sample follow-up results

Day 21Scale

Payment reconciliation

  • Match Stripe payments to access tokens
  • Record refunds and fees
  • Reconcile with TrustMRR-connected account
  • Fix any access mismatches

Deliverable: Payment and access audit

Week 4 · Scale what works · 7 days
Day 22Quality

Test and hint quality pass

  • Compile 10 founder-authored snippets
  • Fix wrong or weak tests
  • Improve hint wording
  • Reject unsupported snippet patterns

Deliverable: Quality benchmark notes

Day 23Quality

Custom thresholds and titles

  • Add custom pass threshold
  • Add custom exercise titles
  • Add instructor instructions field
  • Retest export

Deliverable: More sellable exercise controls

Day 24Quality

Unconverted follow-up

  • Send final sample follow-up
  • Offer $29 single exercise
  • Ask for one blocker
  • Update FAQ from blockers

Deliverable: Last follow-up wave sent

Day 25Quality

Studio Pack push

  • Send Studio Pack offer to warm leads
  • Emphasize 30 exercises and priority
  • Add cohort deadline urgency
  • Close any pending pack

Deliverable: Studio Pack pipeline

Day 26Quality

Feedback and sample page

  • Collect permission for anonymized example
  • Publish sample exercise page
  • Add feedback quotes only if approved
  • Update offer page

Deliverable: Public sample page

Day 27Quality

Fix top blocker

  • Choose top customer blocker
  • Ship smallest useful fix
  • Retest affected samples
  • Notify affected lead

Deliverable: Blocker fix shipped

Day 28Quality

Final outreach wave

  • Send 50 final DMs
  • Follow up all warm leads
  • Post final sample offer
  • Log all replies

Deliverable: Final outreach complete

Days 29-30 · Consolidate · 2 days
Day 29Close

Verify payments and access

  • Verify all payments and refunds
  • Check every paid access token
  • Reconcile Stripe with TrustMRR
  • Fix any mismatches

Deliverable: Verified payment records

Day 30Close

Wrap and next cohort

  • Write final 30-day report
  • List best lead sources
  • Plan next cohort refresh offer
  • Shut down nonessential work

Deliverable: Final report and next-step plan

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: 4 sales, mostly $99 Lesson Packs, no paid ads.
  • Base: 14 sales with $249 blended ARPU across Single, Lesson, and Studio Packs, organic outreach only.
  • Upside: 40 Studio Pack sales at $499, matching the concept monetization hypothesis, with one refund and $200 paid promotion.
  • Payment fees assume Stripe Payment Links at roughly 4% effective processing cost.
  • Operating costs cover Vercel, Supabase, domain, OpenAI usage, and email tooling; hosting and API delivery are not deducted from hackathon profit.
  • No customers or payments before launch; revenue flows through a TrustMRR-connected payment account.
  • All scenarios are projections, not verified revenue.

Conservative

4 customers
$396
collected revenue · avg payment $99
Refunds
$0
Chargebacks
$0
Payment fees
$16
Paid marketing
$0
Hackathon profit
$380
Operating costs
$40
Business profit
$340

Base case

14 customers
$3,486
collected revenue · avg payment $249
Refunds
$0
Chargebacks
$0
Payment fees
$139
Paid marketing
$0
Hackathon profit
$3,347
Operating costs
$160
Business profit
$3,187

Optimistic

40 customers
$19,960
collected revenue · avg payment $499
Refunds
$499
Chargebacks
$0
Payment fees
$798
Paid marketing
$200
Hackathon profit
$18,463
Operating costs
$650
Business profit
$17,813

Model your own numbers

Runs in your browser · nothing is saved
Collected revenue
$406
Payment fees (3.9%)
$16
Paid marketing
$0
Hackathon profit
$390
Business profit
$230

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.

Section 7 of 8

Main risks and validation experiments

Risk 1Generated tests are brittle or too easy, so instructors reject the exercise.

Mitigation

Keep tests deterministic, let instructors edit expected outputs, and manually review every free sample before delivery.

Validation experiment

Compile 10 founder-authored JavaScript snippets and time how long each needs to become usable.

Kill criteria

Abandon the auto-test approach if fewer than 7 of 10 snippets are usable after 10 minutes of edits.

Risk 2Free sample delivery consumes the founder's calendar and caps sales capacity.

Mitigation

Cap delivery at 3 samples per day and use a fixed 10-minute checklist per sample.

Validation experiment

Track minutes per sample for the first 10 deliveries.

Kill criteria

Reduce sample scope to one exercise only if the average exceeds 90 minutes per sample.

Risk 3Instructors prefer free katas or existing LMS authoring tools.

Mitigation

Show a side-by-side sample built from their own lesson code and emphasize offline HTML export.

Validation experiment

Ask 10 target instructors whether the sample matches their lesson better than their current workflow.

Kill criteria

Kill the wedge if fewer than 2 of 10 instructors say the sample is usable for their next lesson.

Risk 4Browser code execution creates security or reliability problems.

Mitigation

Use Web Worker timeouts, block network access paths, keep secrets out of the runner, and test malicious snippets before public links.

Validation experiment

Run infinite loop, error, and network-access snippets before the first public sample.

Kill criteria

Do not publish public exercise links if containment cannot be demonstrated within two build days.

Risk 5The $499 Studio Pack triggers approval friction for independent instructors.

Mitigation

Lead with $29 and $99 offers, then offer $499 only after a sample is accepted.

Validation experiment

Offer both the $99 Lesson Pack and $499 Studio Pack to 10 warm sample recipients.

Kill criteria

If all warm leads stall on approval at $499, keep the first 30 days focused on $29 and $99 packs.

Section 8 of 8

Hour-by-hour: the first 24 hours

Hours 1-2

  • Create Next.js and TypeScript repo
  • Deploy blank Vercel app
  • Define exercise schema

Output: Live shell and schema

Hours 3-4

  • Wire Babel parser
  • Select candidate AST gaps
  • Render masked starter code from one snippet

Output: Parser prototype

Hours 5-6

  • Add CodeMirror editor
  • Run student code in Web Worker
  • Implement one deterministic test

Output: Passing and failing student flow

Hours 7-8

  • Add Stripe Payment Link placeholder
  • Add access-token check
  • Create HTML export skeleton

Output: End-to-end sample path

Hours 9-10

  • Write free-sample offer
  • Build first 20-lead list from LinkedIn
  • Prepare DM tracking sheet

Output: Outreach copy and first lead batch

Complete report

Full 30-day launch report

Read the full generated report

1. Product opportunity and positioning

GapKata Studio sells a single output to a single buyer: a graded browser exercise built from the instructor's own JavaScript solution code. The buyer is the owner or lead instructor at a 1-10 person JavaScript/React bootcamp or corporate technical training firm preparing a cohort. The painful task is converting working solution code into starter code with teachable gaps, hidden tests, progressive hints, and a safe student runner. Generic katas do not match the lesson, and LMS authoring tools take too long. JEV scores the concept 58.4/100 in the C band; speed to first revenue is the strong point, market demand is the weak point. The plan therefore narrows to a free sample offer and direct outreach, not a platform launch. The product is not a learner course library and not a personalized tutorial engine. It is a code-to-exercise compiler with a static artifact at the end. The commercial bet is that an instructor can judge the sample in minutes and pay by card without procurement.

2. Smallest sellable MVP

The smallest sellable unit is one instructor-supplied snippet compiled into one exercise with editable tests, three hints, a gated solution diff, a hosted link, and an HTML download. The founder can deliver the first samples with manual review while the compiler handles AST masking and HTML packaging. Must-have features include the snippet form, Babel gap selection, starter TODOs, deterministic tests, CodeMirror editor, Web Worker execution, pass/fail output, hint ladder, solution diff, publish and export, and Stripe token gating. Out of scope: Python, LMS/SCORM, student accounts, analytics, video, SSO, and team collaboration. Demo flow: instructor pastes code; selects concept and difficulty; reviews gaps and tests; edits one hint; publishes; student fills gaps, runs tests, and reveals hints. Build time is five days.

3. Technical implementation plan

Stack: Next.js on Vercel, TypeScript, Supabase Postgres, Babel parser/traverse/generator, CodeMirror 6, Web Worker sandbox, OpenAI API for hint and test suggestions, Stripe Payment Links, and static HTML export. Architecture: the app stores an exercise record; a server route parses the snippet and proposes gaps; the instructor edits tests and hints; publishing renders a static exercise page and a single-file HTML bundle; the browser runner executes student code in a Web Worker with timeouts and no network access. Build steps: scaffold and schema; AST gap compiler; starter generation; test harness; editor runner; hint and diff generation; publish/export; Stripe token gate; sample workflow; deploy. The hardest risk is brittle generated tests on arbitrary snippets. AI suggests tests, classifies teachable nodes, and drafts hints, but the instructor approves the final test set.

4. Pricing and monetization

Pricing is one-time packs, not a subscription: $29 for one exercise, $99 for five, and $499 for 30 exercises with priority generation and offline HTML bundles. The first revenue offer is a free compiled sample within 24 hours, then a $99 Lesson Pack if the sample fits. Expected first-year ACV in this plan is $249, a blended projection across packs. The repeat path is cohort refresh: each new module or cohort needs new exercises, so the instructor buys another pack rather than paying a monthly fee. Do not discount the $499 pack into a loss; each sale must cover AI and hosting delivery. No customer, revenue, or partnership is claimed here.

5. First-customer acquisition

The primary channel is direct LinkedIn and X outreach to independent JavaScript bootcamp owners and lead instructors. Build a list from LinkedIn searches such as JavaScript bootcamp owner, lead instructor React bootcamp, and small bootcamp team pages; avoid marketplaces. Send 20-25 short DMs per day offering one free compiled sample from an existing lesson solution. Deliver within 24 hours, ask for one concrete feedback item, then offer the $99 Lesson Pack and the $499 Studio Pack. Follow up after 48 hours with the offline HTML export option for LMS use. Week one goal: 75 qualified leads listed, 40 DMs sent, 6 sample acceptances, and 2 paid-pack conversations. The message must be specific and no-call.

6. Detailed 30-day execution roadmap

Days 1-5: build and deploy the sellable MVP; no customer work before launch. Day 5 is the MVP deadline. Days 6-7: build the 75-lead list, publish a sample offer page, and send the first 25 DMs. Week 2, days 8-14: deliver 2-4 free samples per day, fix the top rejection reason, send 40 more DMs, target the first sale on day 12, then fulfill the paid pack. Week 3, days 15-21: second outreach wave to bootcamp owners and corporate trainers, add a cohort-refresh repeat offer, improve HTML export, harden the sandbox, and reconcile Stripe against TrustMRR. Week 4, days 22-28: quality pass on tests and hints, add custom pass thresholds and titles, follow up all warm samples, push Studio Packs, publish an anonymized sample page, and send a final 50-DM wave. Days 29-30: verify payments, refunds, access tokens, and TrustMRR records; ship the final report and plan the next cohort.

7. Revenue and profit scenarios

Scenarios are projections only. Conservative: 4 sales at $99 = $396 gross, $16 payment fees, $0 ads, $40 operating costs. Base: 14 sales at $249 blended ARPU = $3,486 gross, $139 fees, $0 ads, $160 operating costs. Upside: 40 Studio Packs at $499 = $19,960 gross, one $499 refund, $798 fees, $200 paid promotion, $650 operating costs. Payment fees assume Stripe Payment Links at roughly 4%. Hackathon profit excludes hosting, domains, software, and AI/API delivery. Business profit subtracts operating costs. In the base projection, business profit is about $3,187; this is a hypothesis, not verified revenue. No existing customers or traction are claimed.

8. Main risks and validation experiments

Brittle tests: if 10 founder-authored snippets produce fewer than 7 usable exercises after 10 minutes of edits, stop scaling generation and add a test-editing wizard. Free samples eat the calendar: cap at 3 per day and track minutes per sample; if the average exceeds 90 minutes, reduce sample scope to one exercise only. Buyer prefers free katas or LMS tools: show 10 instructors a side-by-side sample and ask whether it matches their lesson; kill the wedge if fewer than 2 of 10 say usable. Sandbox risk: test timeout, infinite loops, network access, and secret leakage before any public link; do not publish if containment fails. Price friction at $499: lead with $29 and $99, and use $499 only after a sample is accepted.

9. First 24-hour action plan

Hours 1-2: create the Next.js repo, deploy a blank Vercel app, and define the exercise schema. Output: live shell and schema. Hours 3-4: wire Babel parser and render masked starter code from one founder snippet. Output: parser prototype. Hours 5-6: build the CodeMirror runner with a Web Worker and one deterministic test. Output: passing and failing student flow. Hours 7-8: add a payment link placeholder, access token check, and HTML export skeleton. Output: end-to-end sample path. Hours 9-10: write the free-sample offer and list 20 target instructors from LinkedIn. Output: outreach copy and first lead batch.

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 →