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

Branchline SCORM Compiler

Turns a plain-text SOP or policy into a playable branching decision scenario, exported as a ready-to-upload SCORM 1.2 zip.

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.38/10
MVP build (solo)
4 days
Launch price
$149
Sales to $1,000 revenue
7 customers
First paying customer
Direct LinkedIn DMs to freelance instructional designers, backed by one post in r/instructionaldesign.
Who pays

Solo or 2-5 person instructional-design / e-learning freelance shops building compliance, onboarding or safety courses for corporate clients that require SCORM 1.2 delivery into an LMS (US/UK/CA/EU).

Biggest execution risk

Monetization potential 5.2/10

Why this could work in 30 days: one founder can ship the MVP in 4 days; the plan targets a first sale on day 11; 7 sales at $149 clears $1,000 of collected revenue; strongest signal is speed to first revenue at 8.2/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

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

0/12
Entry price
$149
Solo build
4 days
30d base revenue
$1,700
30d hackathon profit
$1,623
Section 1 of 8

Product opportunity and positioning

Target customer

Solo or 2-5 person instructional-design / e-learning freelance shops building compliance, onboarding or safety courses for corporate clients that require SCORM 1.2 delivery into an LMS (US/UK/CA/EU).

Why now

Freelance IDs already have the source text and an LMS to deliver into, so the SCORM zip is a concrete artifact they can bill a client for this week, with no procurement, integration or pilot cycle.

Problem

Branching scenarios are the slowest part of a course build: the designer hand-draws the decision tree, rebuilds it click-by-click in Storyline or Captivate, and only discovers dead ends and unreachable branches after the client reviews it.

Solution

Paste 200-800 words of policy or SOP text, get an editable decision graph on a node canvas, run a graph linter, then compile the approved graph into a self-contained SCORM 1.2 zip with imsmanifest.xml, a single-page player, per-choice scoring and an end-of-scenario summary.

Differentiation · Storyline AI features are bundled into a full authoring suite the freelancer already pays for; Branchline is a one-time per-project purchase that outputs a finished SCORM zip from existing text, not a new tool to learn.

1. Product opportunity and positioning

Branchline SCORM Compiler targets a narrow, already-paying professional: the freelance instructional designer who builds compliance, onboarding and safety courses for corporate clients. That buyer has three properties that make a 30-day launch realistic. They already possess the source material (an SOP, a policy PDF, a safety procedure), they already have a delivery target (a client LMS that accepts SCORM 1.2), and they already charge the client for the scenario build. Nothing has to be created from nothing and nothing has to be approved by procurement.

The pain is specific and measurable in hours. A branching scenario in Storyline means drawing the decision tree on paper or in a diagram tool, then rebuilding every node, choice and feedback screen inside the authoring tool. Structural mistakes — a dead end with no remediation, a branch nobody can reach, a choice with no consequence — usually surface after the client reviews the draft, which means rework inside a fixed-fee project. Branchline attacks exactly that sequence: text in, editable graph out, structural linter, SCORM zip.

Positioning is deliberately not 'authoring tool replacement'. The promise is one artifact, one price, one afternoon saved. The buyer keeps Storyline for the parts of the course that need it and uses Branchline for the branching conversation that would otherwise eat 6-10 hours.

The product inherits the original Hyperpad DNA — non-developers assembling behaviour logic as a visual node graph — but repoints it at a professional who is already paid to ship one small interactive artifact. It is not a children's product, not a homeschool subscription, not a daily puzzle habit. The buyer is an adult freelancer, the output is a file their client accepts, and the payment is a one-time per-project charge. That is a materially different business from the Logic Debugging Academy scenario.

The JEV score of 63.8 (band C) is honest about the trade-offs. Speed to first revenue (8.24 normalized) and reachable customers (7.02) are the strengths the plan leans on. Monetization potential (5.19) and operational simplicity (5.3) are the weak spots, which is why the roadmap stays on a single $149 SKU, caps scope at SCORM 1.2, and avoids any hosting, LMS or progress-tracking obligation.

Section 2 of 8

Smallest sellable MVP

A web app where a freelancer pastes SOP text, gets an editable decision graph, sees a lint report, and downloads one SCORM 1.2 zip after paying $149 at Stripe Checkout.

Must-have features

  • Text-to-graph generator returning schema-validated JSON (nodes, choices, feedback, remediation links)
  • React Flow canvas to edit node text, add or delete choices, and rewire links
  • Graph linter flagging dead ends, unreachable nodes, consequences-free choices and loops with no exit
  • SCORM 1.2 packager producing imsmanifest.xml plus a single-page player, zipped client-side
  • Preview player with per-choice scoring and an end-of-scenario summary screen
  • Stripe Checkout that unlocks the download and persists the project
  • Landing page with one live clickable demo scenario built from a public first-aid SOP

Explicitly out of scope

  • SCORM 2004, xAPI or cmi5 output
  • LMS, hosting or learner-progress analytics
  • Voiceover, video, avatars or character art
  • Team collaboration, comments or version branches
  • Storyline or Captivate import/export
  • Accounts, teams and seat-based billing
  • Email drip onboarding or a template marketplace

Demo flow (what the buyer sees)

  1. Visitor opens the landing page and plays the pre-built first-aid branching demo to the summary screen.
  2. They paste 200-800 words of their own SOP into the generator and click Generate.
  3. The graph appears on the canvas in about 30 seconds with nodes and choices laid out.
  4. They open the lint panel and see flagged dead ends and unreachable nodes with jump-to-node links.
  5. They edit two node texts, rewire one choice, and re-run the linter until it reports clean.
  6. They hit Preview, play through, and see the score and summary.
  7. They hit Export, land on Stripe Checkout at $149, pay, and the zip downloads immediately.
Build plan

Technical implementation plan

Stack

Next.js (App Router) on VercelReact Flow for the node canvasOpenAI or Anthropic chat completion API for graph generationZod for graph schema validationJSZip for client-side SCORM packagingSupabase Postgres for saved projectsStripe Checkout + webhookTailwind CSS

Architecture

A Next.js app on Vercel serves the landing page, the canvas workspace and one serverless route that calls the LLM. The LLM returns JSON which is validated with Zod; invalid output is retried once with the validation error appended, then surfaced as a fixable error. Projects are stored in Supabase as a JSON graph column keyed by a project id; a signed browser session keeps the workspace usable without forcing account creation before purchase. The linter is pure TypeScript over the graph object, so it runs instantly client-side and is reused by the compiler. The compiler renders a static HTML player template with the graph injected as JSON, plus a small SCORM 1.2 API adapter, then zips index.html, the adapter and imsmanifest.xml with JSZip in the browser so no file ever sits on a server. Stripe Checkout with a webhook marks the project as paid and unlocks the export button.

Build steps

  1. Create the Next.js repo, deploy the skeleton to Vercel, and connect a Supabase project with a projects table.
  2. Define the graph Zod schema (id, title, nodes, choices, feedback, scoring, remediation target).
  3. Write the generation route: prompt plus schema, one retry on validation failure, save draft to Supabase.
  4. Build the React Flow canvas: node text editing, add/delete choice, connect handles, autosave.
  5. Implement the linter as pure functions and a right-hand panel with jump-to-node links.
  6. Build the preview player with scoring and summary screen, reusing the same player component as the export.
  7. Write the SCORM 1.2 adapter (LMSInitialize, LMSSetValue, LMSCommit, LMSFinish) and imsmanifest.xml template.
  8. Zip the player package in the browser with JSZip and trigger the download.
  9. Add Stripe Checkout for $149 and $499, a webhook, and a paid flag that gates the export route.
  10. Load the first-aid demo scenario and record a 60-second screen capture.
  11. Harden: rate-limit the generation route, cap input length, add an error state for unparseable text.

AI components

  • LLM generates the decision graph (nodes, choices, consequence feedback, remediation links) from pasted SOP text
  • LLM produces short consequence feedback per choice, constrained to one or two sentences
  • Optional second pass that rewrites any node the linter flags as having no consequence
Hardest technical risk: SCORM 1.2 LMS compatibility: the player must find the LMS API object across Moodle, TalentLMS, Docebo and Cornerstone variants and still degrade gracefully to standalone preview when no API exists.
Section 3 of 8

Pricing and monetization

Scenario Export

Entry offer
$149 one-time

For Freelance instructional designer shipping one branching course

  • One SCORM 1.2 zip export
  • Unlimited regenerations and edits of that scenario
  • Graph linter report
  • Editable project saved for 12 months

Studio (5 exports)

$499 one-time

For Small ID shop with several client courses in flight

  • Five SCORM 1.2 exports
  • All linter reports
  • Priority email support

Model: One-time per-project payment; the free tier is a live demo plus a free graph lint, and the paid unit is a SCORM 1.2 export.

First revenue offer: Send one page of SOP or policy text; get back a linted, playable SCORM 1.2 branching scenario. First three get it free for a written testimonial and one referral; from the fourth it is $149, paid by Stripe, delivered in under 24 hours manually until self-serve export is live.

Expected ACV: $170

Upsell path: A single-project buyer returns for the next client course at $149; a buyer with three courses in flight is offered Studio at $499 instead of three separate $149 purchases. Repeat buyers get a referral ask rather than a discount.

Target customers
20
Revenue model
$2,980
Costs
$120
Profit model
$2,860
Section 4 of 8

First-customer acquisition

Primary channel

Direct LinkedIn DMs to freelance instructional designers, backed by one post in r/instructionaldesign.

Where to find them

  • LinkedIn search: 'instructional designer' plus 'freelance'
  • LinkedIn search: 'instructional designer' plus 'Articulate Storyline'
  • LinkedIn search: 'e-learning consultant' plus 'compliance training'
  • r/instructionaldesign commenters asking about branching scenarios
  • r/elearning threads about SCORM packaging problems
  • Public e-learning agency 'about' pages listing 2-5 contractors
  • Freelance ID profiles on Upwork that mention Storyline and SCORM
  • LinkedIn commenters on vendor posts about scenario-based learning

Exact outreach motions

  • Wave 1: 15 LinkedIn DMs to the first 15 names on the list, each referencing something specific on their profile.
  • Post one short r/instructionaldesign message offering a free branching-scenario lint to anyone who pastes their source text.
  • Day 2 follow-up on wave 1 with one line: 'happy to just lint your existing scenario, no cost'.
  • Deliver the first three free exports within 24 hours and ask for a written testimonial plus one referral name.
  • Wave 2: 15 more DMs, now leading with the before/after lint screenshot from a delivered build.
  • Day 4 post-delivery check: 'did the client accept the zip?' and capture the exact objection if not.
  • Ask every buyer for one named referral to another ID in their network on day 7.

Message template

Hi [Name] — I saw you build branching scenarios in Storyline for compliance clients. I'm building a tool that turns a page of SOP or policy text into an editable decision graph, lints it for dead ends, and exports a SCORM 1.2 zip. I'm giving the first three away free to get feedback: send me one page of text and I'll send back a playable zip within 24 hours. Interested?
Week-one goal: 40 named prospects logged with profile links and niche, 30 DMs sent, 1 subreddit post live, 3 source-text submissions received.
Section 5 of 8

30-day execution roadmap

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

Ship a shell with payments wired

  • Create Next.js repo, deploy to Vercel, connect Supabase.
  • Create Stripe account, connect TrustMRR, keep it in test mode.
  • Publish a one-page landing with the demo CTA and waitlist field.

Deliverable: Live landing page plus a payment account connected to TrustMRR.

Day 2Generator

Text in, valid graph out

  • Define the Zod graph schema.
  • Write the LLM prompt and the retry-on-invalid loop.
  • Run 3 public SOP texts through it and record what breaks.

Deliverable: Generation route returning schema-valid JSON graphs.

Day 3Canvas

Make the graph editable

  • Render nodes with React Flow from the generated JSON.
  • Add node text editing, choice add/delete and handle rewiring.
  • Autosave the graph to Supabase.

Deliverable: Editable canvas that persists projects.

Day 4Linter and preview

Prove the structural value

  • Implement dead-end, unreachable, no-consequence and no-exit checks.
  • Build the preview player with per-choice scoring and a summary screen.
  • Add a lint panel with jump-to-node links.

Deliverable: Playable preview plus a lint report.

Day 5SCORM exportMVP shipped

The deliverable buyers pay for

  • Write the SCORM 1.2 API adapter and imsmanifest.xml template.
  • Zip index.html, adapter and manifest client-side with JSZip.
  • Test the zip in a free SCORM Cloud sandbox; fix launch and completion errors.

Deliverable: Downloadable SCORM 1.2 zip that launches and completes in a sandbox.

Day 6Gating

Turn export into revenue

  • Add Stripe Checkout for $149 and $499.
  • Add the webhook and a paid flag that unlocks export.
  • Run one end-to-end test purchase with a test card.

Deliverable: Self-serve paid export flow working end to end.

Day 7Demo

Something to click before any DM

  • Build the first-aid demo scenario from a public SOP.
  • Record a 60-second screen capture of generate, lint, export.
  • Publish the demo page and embed the video.

Deliverable: Public demo plus a short screen capture.

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

40 named prospects

  • Run the four LinkedIn searches and log 40 names.
  • Note each prospect's niche and a specific profile detail.
  • Score each name for branching-scenario likelihood.

Deliverable: Prospect sheet with 40 qualified freelance IDs.

Day 9Outreach wave 1

30 DMs is the job

  • Send 15 personalised LinkedIn DMs using the template.
  • Post the free-lint offer in r/instructionaldesign.
  • Log every send and reply in the sheet.

Deliverable: 15 DMs sent and 1 subreddit post live.

Day 10Fulfilment

Deliver before selling

  • Manually build the free exports for anyone who sent source text.
  • Send each zip with a one-paragraph lint summary.
  • Ask for a testimonial line and one referral name.

Deliverable: Up to 3 delivered SCORM zips with responses logged.

Day 11First saleFirst sale target

Convert a reply into a payment

  • Follow up on every wave 1 reply with the $149 checkout link.
  • Send 15 more DMs to the rest of the list.
  • Close the first paid export and deliver it same day.

Deliverable: First paid Stripe charge inside the contest window.

Day 12Instrumentation

Know where the funnel leaks

  • Add funnel events: generate, lint, preview, checkout, download.
  • Review which step loses the most projects.
  • Fix the single biggest drop-off with a copy or UX change.

Deliverable: Funnel dashboard with one shipped fix.

Day 13Proof post

Publish the before/after

  • Post the lint screenshot: input text, flagged dead ends, clean output.
  • Republish the same image on LinkedIn as a text post.
  • Reply to every comment within two hours.

Deliverable: Before/after lint post live in two channels.

Day 14Review

Week 2 data call

  • Count DMs sent, replies, source submissions, paid sales.
  • Reprice or re-message based on the dominant objection.
  • Build the next 30-name list from replies and referrals.

Deliverable: Week 2 metrics note and a refreshed prospect list.

Week 3 · Repeat & systematize · 7 days
Day 15Offer test

Test the Studio tier

  • Add the Studio $499 line to every DM going forward.
  • Send 15 DMs with the Studio option included.
  • Record which tier the replies ask about.

Deliverable: Two-tier offer live with a reply tally.

Day 16Outreach wave 3

Volume plus follow-up

  • Send 15 new DMs.
  • Follow up on all unanswered wave 1 and 2 messages once.
  • Deliver any pending paid exports within 24 hours.

Deliverable: 15 new DMs plus 30 follow-ups logged.

Day 17LMS compatibility

Kill the support-load risk early

  • Test the exported zip in two more LMSs on free tiers.
  • Write a compatibility note on known issues.
  • Ship a fix for any blocking launch failure.

Deliverable: Three-LMS compatibility matrix published.

Day 18Inbound asset

A page that answers the real question

  • Publish a short SCORM 1.2 branching checklist page.
  • Link it from every DM follow-up.
  • Add a mailto capture for the checklist.

Deliverable: Indexable checklist page with email capture.

Day 19Referrals

Ask the buyers

  • Email every buyer asking for one named referral.
  • Offer a free lint to each referred name.
  • Send 15 DMs to referred and adjacent names.

Deliverable: Referral requests sent and tracked.

Day 20Friction fix

Highest-volume support topic

  • Tag every support message by theme.
  • Fix the top theme in the product, not in email.
  • Update the demo to reflect the fix.

Deliverable: Top support theme reduced to a product change.

Day 21Review

Week 3 data call

  • Recount funnel and revenue by tier.
  • Decide whether to keep or drop the Studio tier.
  • Set the final nine-day target.

Deliverable: Week 3 metrics note with a go-forward decision.

Week 4 · Scale what works · 7 days
Day 22Outreach wave 4

New segment

  • Send 20 DMs to compliance and safety-training IDs.
  • Load a second demo scenario from a safety SOP.
  • Log every reply with the vertical tag.

Deliverable: 20 DMs sent with vertical tagging.

Day 23Second proof post

Show the linter catching a real bug

  • Post a concrete dead-end catch with the fixed graph.
  • Cross-post to r/elearning.
  • Reply to all comments same day.

Deliverable: Second proof post in two channels.

Day 24Repeat buyers

Move repeat demand to Studio

  • Offer Studio to anyone who bought or asked twice.
  • Add a one-line Studio comparison to the checkout page.
  • Deliver all pending exports same day.

Deliverable: Studio upsell live on the checkout page.

Day 25Outreach wave 5

Last broad sweep

  • Send 20 DMs to the remaining list.
  • Follow up every non-responder once with the proof image.
  • Track cost per reply in API spend.

Deliverable: 20 DMs plus 40 follow-ups logged.

Day 26Export options

One requested feature only

  • Ship per-choice scoring options and a summary toggle.
  • Update the demo to show both.
  • Announce it to all existing buyers.

Deliverable: Configurable scoring shipped.

Day 27Referral loop

Turn buyers into a channel

  • Send every buyer a one-click referral message they can forward.
  • Offer a free lint for each forwarded name.
  • Send 15 DMs to new names from referrals.

Deliverable: Referral loop running with a tracked link.

Day 28Review

Week 4 data call

  • Reconcile Stripe revenue against TrustMRR.
  • Identify the single highest-converting message.
  • Rebuild the DM template around it.

Deliverable: Revenue reconciliation and a revised template.

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

Convert open conversations

  • Send 25 final DMs and all open-conversation nudges.
  • Ship any same-day fixes blocking a checkout.
  • Deliver every pending export before the window closes.

Deliverable: All open conversations pushed to a decision.

Day 30Close

Reconcile and write it down

  • Confirm every payment settled inside the contest window.
  • Publish a short post: what sold, what did not.
  • Write a post-mortem with the three next bets.

Deliverable: Reconciled revenue record plus a public post-mortem.

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

  • Base: 10 one-time sales over 30 days from roughly 120 targeted DMs plus subreddit posts (projection, not verified).
  • Conservative: 3 sales, all at the $149 Scenario Export tier.
  • Base: blended ARPU of $170 assumes 8 Scenario Export sales at $149 and 2 Studio sales at $499.
  • Upside: 22 sales with blended ARPU of $195, driven by repeat and referral purchases late in the window.
  • Payment fees assume Stripe at 2.9% plus $0.30, modelled at 4.5% of gross revenue including international card mix.
  • Ad spend is $0 in all scenarios; every acquisition action in the plan is organic outreach or free community posting.
  • Refunds are $0 in conservative and base; the upside carries one $149 refund as a contingency, not an observed event.
  • Operating costs cover Vercel Pro, a Supabase tier, a domain and LLM API delivery per export (roughly $0.30-$1.00 per generated graph).
  • Every paid export covers its delivery cost; no scenario relies on selling below cost.

Conservative

3 customers
$447
collected revenue · avg payment $149
Refunds
$0
Chargebacks
$0
Payment fees
$20
Paid marketing
$0
Hackathon profit
$427
Operating costs
$25
Business profit
$402

Base case

10 customers
$1,700
collected revenue · avg payment $170
Refunds
$0
Chargebacks
$0
Payment fees
$77
Paid marketing
$0
Hackathon profit
$1,623
Operating costs
$45
Business profit
$1,578

Optimistic

22 customers
$4,290
collected revenue · avg payment $195
Refunds
$149
Chargebacks
$0
Payment fees
$193
Paid marketing
$0
Hackathon profit
$3,948
Operating costs
$90
Business profit
$3,858

Model your own numbers

Runs in your browser · nothing is saved
Collected revenue
$1,490
Payment fees (3.9%)
$58
Paid marketing
$0
Hackathon profit
$1,432
Business profit
$1,387

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.

All three scenarios are projections built from the stated assumptions. They are not verified revenue, not existing customers and not a forecast of results.

Section 7 of 8

Main risks and validation experiments

Risk 1Generated graphs are shallow or legally wrong, so the designer rewrites them and never exports a second scenario.

Mitigation

Keep the graph fully editable, keep the source text visible beside the canvas, and never auto-publish; the linter report becomes the trust artifact.

Validation experiment

Run 10 real SOPs through the generator and time how long an experienced ID needs to make each graph client-ready.

Kill criteria

If median edit time exceeds 30 minutes across 10 SOPs, narrow the product to the linter and compiler only, feeding graphs in from elsewhere.

Risk 2Buyers expect a Storyline-compatible source file and reject a standalone SCORM zip.

Mitigation

State 'standalone SCORM 1.2 zip, not a .story file' on the landing page and in the first DM line; lead with what their LMS accepts.

Validation experiment

Ask 10 IDs directly in DMs what file format their client's LMS actually requires at hand-off.

Kill criteria

If more than 60% of 10 asked require an editable authoring source file, the export target is wrong and the concept needs rework.

Risk 3Freelancers will not spend $149 on a tool their client has not approved, so replies never become payments.

Mitigation

One-time charge, no subscription, invoice-ready receipt, and a written refund policy covering the first 14 days.

Validation experiment

Split the next 30 DMs between a $149 link and a $99 link and compare checkout starts.

Kill criteria

If 120 qualified DMs produce zero paid sales, the willingness-to-pay assumption is falsified and the offer must change before more outreach.

Risk 4SCORM 1.2 quirks across client LMSs create support load a solo founder cannot absorb inside 30 days.

Mitigation

Ship a compatibility checklist, test against three LMSs, and publish known issues so buyers self-serve.

Validation experiment

Upload the same zip to three LMS free tiers and record every launch or completion failure.

Kill criteria

If more than 30% of delivered zips hit a blocking LMS failure, pause outreach until packaging is hardened.

Risk 5Existing authoring suites ship their own AI scenario builders and compress willingness to pay.

Mitigation

Compete on time and price per project, not on features: text in, SCORM out, one-time fee, no new tool to learn.

Validation experiment

Ask every reply which tool they would otherwise use and what it costs them in hours.

Kill criteria

If replies consistently say their current suite already does this well enough, pivot to the linter as a standalone audit tool.

Section 8 of 8

Hour-by-hour: the first 24 hours

Hours 1-3

  • Create the Next.js repo and deploy a placeholder to Vercel.
  • Create the Supabase project and a projects table.
  • Open Stripe, connect TrustMRR, confirm no customers or payments exist yet.

Output: Deployed skeleton and a payment account connected before any launch activity.

Hours 4-7

  • Write the graph Zod schema.
  • Write the generation prompt and the retry-on-invalid loop.
  • Run two public SOP texts through it and save the raw outputs.

Output: A working text-to-graph call returning valid JSON.

Hours 8-11

  • Run the four LinkedIn searches and log 20 names with profile links.
  • Tag each name by niche and branching-scenario likelihood.
  • Draft the personalised first line for the top 10.

Output: A 20-name prospect sheet with drafted openers.

Hours 12-14

  • Write the landing page headline, offer and demo CTA.
  • Write the DM template and the free-lint offer line.
  • Publish the landing page and log the day-1 baseline.

Output: Live landing page plus a ready-to-send DM template.

Complete report

Full 30-day launch report

Read the full generated report

Branchline SCORM Compiler — 30-Day Solo Launch Report

1. Product opportunity and positioning

The buyer is a freelance instructional designer, usually one to five people, building compliance, onboarding or safety courses for corporate clients. That buyer is unusually good news for a solo founder in 30 days: they already hold the source text, they already have a client LMS that takes SCORM 1.2, and they already charge for the scenario build. Nothing needs procurement, integration or a pilot.

The pain is measurable in hours. A branching scenario means drawing a decision tree, then rebuilding every node, choice and feedback screen in Storyline or Captivate. Structural faults — a dead end with no remediation, an unreachable branch, a choice with no consequence — usually surface after client review, which means unpaid rework inside a fixed-fee project. Branchline compresses that to: paste text, edit the graph, run the linter, download the zip.

Positioning is deliberately not 'authoring tool replacement'. The promise is one artifact, one price, one afternoon saved. The designer keeps Storyline for the rest of the course and uses Branchline only for the branching conversation that would otherwise consume 6-10 hours.

The product keeps the original Hyperpad DNA — non-developers assembling behaviour logic as a visual node graph — but repoints it at an adult professional already paid to ship one small interactive artifact. It is not a children's product, not a homeschool subscription, not a daily puzzle habit. The output is a SCORM file a client accepts, and the payment is a one-time per-project charge.

The JEV score of 63.8 (band C) is an honest read. Speed to first revenue and reachable customers are the strengths this plan leans on. Monetization potential and operational simplicity are the weak spots, which is why the plan holds a single $149 SKU, caps output at SCORM 1.2, and refuses any hosting, LMS or progress-tracking obligation.

2. Smallest sellable MVP

The sellable unit is one SCORM 1.2 zip generated from the buyer's own SOP text, with an editable graph and a lint report in front of it. Seven features, nothing else: text-to-graph generation, a node canvas, the linter, the packager, a preview player with scoring and summary, Stripe checkout that unlocks the download, and a landing page carrying one live demo scenario.

Explicitly out: SCORM 2004, xAPI, cmi5, any LMS or analytics, video or voiceover, collaboration, Storyline import, and seat billing. Each of those adds a support surface a solo founder cannot staff in December.

The demo flow is the sales pitch: play the first-aid demo, paste your own text, watch the graph appear, see four dead ends flagged, fix one, preview, pay, download.

3. Technical implementation plan

Next.js on Vercel serves the landing page, the canvas and one serverless generation route. The LLM returns JSON, validated with Zod, retried once with the validation error appended, then surfaced as a fixable error rather than a crash. Projects live in Supabase as a JSON graph column keyed by project id, with a signed browser session so nobody has to create an account before paying.

The linter is pure TypeScript over the graph object — dead ends, unreachable nodes, consequence-free choices, loops with no exit — so it runs instantly in the browser and is reused by the compiler. The compiler renders a static single-page player with the graph injected as JSON, plus a small SCORM 1.2 API adapter, then zips index.html, the adapter and imsmanifest.xml with JSZip in the browser. No learner file ever sits on a server. Stripe Checkout plus a webhook sets a paid flag that unlocks export.

The one thing most likely to break is SCORM 1.2 API discovery across Moodle, TalentLMS, Docebo and Cornerstone variants. That is why day 5 ends with a sandbox launch test and day 17 adds two more LMSs, before outreach scales.

4. Pricing and monetization

Two one-time tiers: Scenario Export at $149 for one zip with unlimited regenerations, and Studio at $499 for five exports plus priority email. No subscription, because a freelancer cannot justify recurring spend on a per-project tool and a subscription would invite churn inside the contest window.

Expected blended ARPU in the base case is $170, assuming most sales are single exports with a minority upgrading. The upsell path is repetition, not expansion: the same buyer returns for their next client course, or moves to Studio when they have three courses in flight. Referral asks replace discounting.

5. First-customer acquisition

One channel: direct LinkedIn DMs to freelance instructional designers, backed by one r/instructionaldesign post. Four LinkedIn searches ('instructional designer' + 'freelance', + 'Articulate Storyline', + 'e-learning consultant' + 'compliance training') produce the list; subreddit commenters asking about branching scenarios or SCORM packaging fill the rest.

The offer is the demo: send one page of SOP text, get back a linted, playable SCORM 1.2 scenario. The first three go free in exchange for a written testimonial and one referral; the fourth pays $149. Week one target is 40 named prospects, 30 DMs, one subreddit post and three source-text submissions. Every delivered zip ends with two questions: did the client accept it, and who else builds branching scenarios.

6. 30-day execution roadmap

Days 1-5 build and ship: repo and payment account on day 1, generator on day 2, canvas on day 3, linter and preview on day 4, SCORM packaging and a sandbox launch test on day 5. The MVP deadline is day 5 and it is a hard gate — no outreach before a zip actually launches in a sandbox.

Days 6-7 add revenue and proof: Stripe gating end to end, then a public first-aid demo and a 60-second capture. Days 8-14 are the first real sales sprint: a 40-name list, 15 DMs plus a subreddit post, free exports delivered manually, a $149 checkout follow-up targeting the first sale on day 11, funnel instrumentation on day 12, a before/after lint post on day 13, and a week-2 metrics call on day 14.

Days 15-21 test the Studio tier in the DM copy, send two more DM waves, publish a three-LMS compatibility matrix, ship a checklist page for inbound, ask every buyer for one named referral, and reduce the top support theme to a product fix. Days 22-28 push a new vertical (compliance and safety IDs), post a second proof image, move repeat buyers to Studio, ship configurable scoring, and run a referral loop. Days 29-30 are the close: 25 final DMs, all pending exports delivered, revenue reconciled against TrustMRR, and a public post-mortem.

7. Revenue and profit scenarios (projections only)

Conservative: 3 sales at $149, gross $447, fees $20, no refunds, no ad spend, operating costs $25. Hackathon profit $427; business profit $402.

Base: 10 sales at blended $170 ARPU, gross $1,700, fees $77, no refunds, no ad spend, operating costs $45. Hackathon profit $1,623; business profit $1,578.

Upside: 22 sales at blended $195 ARPU, gross $4,290, one $149 refund, fees $193, no ad spend, operating costs $90. Hackathon profit $3,948; business profit $3,858.

Every scenario uses organic outreach only, so ad spend is zero throughout. Payment fees assume Stripe at 2.9% plus $0.30, modelled at 4.5% of gross. Operating costs are Vercel, Supabase, a domain and LLM delivery at roughly $0.30-$1.00 per generated graph — low, but non-zero, and every sale covers its own delivery cost. These are projections built from stated assumptions, not verified revenue.

8. Main risks and validation experiments

Shallow or legally wrong graphs are the existential risk. The test is 10 real SOPs with edit time measured; if the median exceeds 30 minutes, the product narrows to linter and compiler only.

Format mismatch is second: buyers may want a .story file. Ten direct DM questions about required hand-off format settle it; above 60% demanding an editable source file, the export target is wrong.

Price resistance is third: a $149 versus $99 split across 30 DMs shows whether checkout starts happen at all. If 120 qualified DMs yield zero paid sales, the willingness-to-pay assumption is falsified.

LMS breakage is fourth: test the same zip on three LMS free tiers. Above a 30% blocking-failure rate, pause outreach until packaging is hardened.

9. First 24-hour action plan

Hours 1-3: repo, Vercel deploy, Supabase table, Stripe connected to TrustMRR with zero customers and zero payments. Hours 4-7: graph schema, generation prompt, two public SOPs through the pipeline. Hours 8-11: 20 named prospects logged with drafted openers. Hours 12-14: landing page live and the DM template ready to send on day 8. Nothing is announced publicly until the sandbox zip launches on day 5.

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 →