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

Hookframe

Hookframe turns an app icon, a few screenshots and one chosen mechanic into a single-file, MRAID-safe playable ad under 5MB that an indie mobile studio can upload to Meta or AppLovin the same day.

One product, one founder, thirty days. Everything below is built to be executed inside the contest window — the official rules still decide what counts.

Decide in 20 seconds

The facts that decide whether this is worth thirty days of yours.

Promising6.83/10
MVP build (solo)
4 days
Launch price
$199
Sales to $1,000 revenue
6 customers
First paying customer
Manual generation of a free, finished playable sample for recently launched indie casual games, sent to the listed developer directly.
Who pays

The marketing/UA lead or solo developer at a 1-10 person mobile game studio (casual, hyper-casual or puzzle) that is already running or about to start a paid UA test on Meta, AppLovin or TikTok, with no in-house creative team.

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 12; 6 sales at $199 clears $1,000 of collected revenue; strongest signal is speed to first revenue at 8.3/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
$199
Solo build
4 days
30d base revenue
$2,688
30d hackathon profit
$2,459
Section 1 of 8

Product opportunity and positioning

Target customer

The marketing/UA lead or solo developer at a 1-10 person mobile game studio (casual, hyper-casual or puzzle) that is already running or about to start a paid UA test on Meta, AppLovin or TikTok, with no in-house creative team.

Why now

Playables are now a standard line item in small-studio UA budgets while agency turnaround is still one to two weeks and DIY attempts get rejected for size or MRAID errors, so a same-day compliant file is a live campaign need rather than a platform evaluation.

Problem

Playable ads are the highest-intent creative format in mobile UA, but a small studio cannot produce one: hand-coding a MRAID wrapper, inlining assets under a hard file-size ceiling and getting the first tap inside a few seconds is a multi-day engineering detour, so the studio skips playables or pays an agency it can barely afford.

Solution

A pay-per-artifact web app: pick one of five parameterized mechanics, upload icon and 2-3 screenshots, set brand colors, CTA copy and end card, then export a ZIP containing a single self-contained index.html with the MRAID wrapper, clickthrough, size-budget report, first-interaction timing check and a one-page upload QA checklist.

Differentiation · Agencies sell a week of design time; free open-source templates ship an unwrapped, oversized HTML file the founder still has to debug. Hookframe sells the finished, size-checked, MRAID-wrapped artifact plus the compliance report that predicts the rejection.

Product opportunity and positioning

Playable ads are the one creative format in mobile user acquisition where the user has already played the game before installing it. For a 1-10 person casual, hyper-casual or puzzle studio running a Meta, AppLovin or TikTok test, that matters because playables usually carry the best conversion intent of any asset in the campaign — and the studio still cannot make one.

The blocker is not design taste. It is the last mile. A hand-coded playable has to inline every image as base64 to survive a hard file-size ceiling, wrap itself in MRAID 2.0 or 3.0 so the network can call isViewable, route the CTA tap to the store listing, and reach first interaction in a couple of seconds or the ad never gets engagement. That is a multi-day engineering detour for a team whose only developer is shipping the game. So the studio either skips playables entirely or buys one from an agency quoting several hundred to a few thousand dollars with a one-to-two-week turnaround.

Hookframe collapses that to a website and a ZIP. The buyer chooses one of five parameterized mechanics — tap-to-collect, dodge-runner, merge-two, slice-swipe, idle-tapper — uploads their icon and two or three screenshots, sets brand colours, CTA copy and an App-Store-style end card, and gets back a single self-contained index.html with all assets inlined, a live size budget against the 5MB ceiling, a measured time-to-first-interaction, and a one-page upload QA checklist. A variant pack exports three hook edits of the same mechanic so the buyer has something to A/B test on day one.

The positioning is deliberately narrow. Hookframe is not a creative platform, not an ad-network integration and not a game engine. It is a per-artifact purchase for a buyer with a live or imminent campaign, priced below one agency day-rate so it clears a company card without procurement. The deliverable is inspectable in a minute and uploadable the same day, which is why the sales cycle is hours rather than weeks.

Three things make this sellable by one person with no audience. First, the buyer is directly reachable: indie mobile games are publicly listed, and new-release lists on the App Store and Play Store are a rolling supply of studios that just launched and now need traffic. Second, the objection that kills DIY — "it gets rejected" — is answered by a document, not by trust. Third, the purchase trigger is a calendar event (a store launch or a budget approval), so timing, not brand, does the qualifying.

The honest weakness is defensibility. Templates are copyable and a determined developer could assemble something similar. The defensible part is the compliance pack and the speed: whoever ships a size-checked, MRAID-wrapped file in ten minutes wins the repeat purchase, and repeat purchases from the same studio are the actual business.

Section 2 of 8

Smallest sellable MVP

A pay-first page where a buyer picks one of five mechanics, uploads icon and screenshots, and receives a ZIP with one self-contained MRAID-wrapped index.html, a size-budget report and a QA checklist.

Must-have features

  • Five parameterized canvas mechanic templates with a slot-based art and copy config
  • Asset ingestion: upload icon and 2-3 screenshots, auto-crop, compress and base64-inline
  • Live size-budget meter showing MB remaining against the 5MB ceiling
  • MRAID 2.0/3.0 wrapper with isViewable gating, CTA clickthrough, end card and zero external network calls
  • Time-to-first-interaction check that flags anything over 3 seconds
  • Variant generator exporting three hook edits in one ZIP
  • Stripe Checkout pay-first with a signed download link emailed on payment, no account required
  • Downloadable one-page upload QA checklist per export

Explicitly out of scope

  • No video ad generation or video-to-playable conversion
  • No ad-network API integration, auto-upload or campaign management
  • No performance dashboard or CPI attribution
  • No team accounts, seats or shared asset library
  • No subscription billing in the first 30 days
  • No bespoke mechanics outside the five templates

Demo flow (what the buyer sees)

  1. Buyer opens the Hookframe landing page and clicks Preview on a sample playable
  2. Buyer picks one mechanic and uploads icon plus two screenshots
  3. Buyer sets brand colours, CTA copy and end-card headline; the size meter updates live
  4. Buyer clicks Buy, pays $199 on Stripe Checkout
  5. Webhook compiles the artifact, stores the ZIP, and emails a signed download link
  6. Buyer opens the ZIP, reads the size-budget and timing report, uploads index.html to Meta
Build plan

Technical implementation plan

Stack

Next.js on VercelTypeScriptVanilla Canvas/JS template runtime (no Phaser)Sharp for crop and compressionCloudflare R2 for ZIP storage and signed URLsStripe Checkout plus webhooksResend for delivery emailOne LLM API call for hook and CTA copy suggestionsPlaywright for automated size and first-interaction checks

Architecture

The site is a Next.js app on Vercel. A build endpoint takes a JSON config (mechanic id, colours, copy, uploaded asset ids) and renders a template: a small vanilla-JS canvas loop plus an HTML shell that carries the MRAID script, the end card and the clickthrough handler. Sharp crops each uploaded image to the template's slot dimensions and walks a compression ladder until the inlined payload fits under a 5MB budget. The compiled file is written to R2 under a random key; Stripe's webhook marks the order paid, then Resend emails a signed, time-limited URL. Playwright loads the compiled file headlessly to record time-to-first-interaction and to assert zero external network requests before the ZIP is sealed.

Build steps

  1. Day 1: scaffold Next.js, domain, Vercel deploy, Stripe account connected to TrustMRR, repo and env vars
  2. Day 2: define the template config schema and build the shared canvas runtime plus HTML shell
  3. Day 3: implement the MRAID 2.0/3.0 wrapper, isViewable gating, CTA clickthrough and end card
  4. Day 4: build the Sharp asset pipeline with a compression ladder and the live size-budget meter
  5. Day 5: wire the export to a single index.html, ZIP it to R2, and email the signed link via a manual test order
  6. Day 6: switch Stripe to live mode, verify the pay-first to delivery flow end to end with a real card
  7. Day 7: add the remaining four mechanics and the Playwright timing and network-isolation check
  8. Day 8: add the variant generator that renders three hook edits into one ZIP
  9. Day 9: ship the landing page with sample previews, exact pricing and the QA checklist

AI components

  • One LLM call that drafts three CTA and hook copy options from the game name and chosen mechanic; the buyer edits or ignores the output
  • No image generation, no video generation, no model in the delivery path
Hardest technical risk: Keeping every template under the 5MB ceiling after all assets are base64-inlined without making screenshots look destroyed; the compression ladder is where quality and compliance fight.
Section 3 of 8

Pricing and monetization

Single Playable

Entry offer
$199 one-time

For Solo dev or UA lead who needs one compliant playable this week

  • One mechanic template
  • One hook variant
  • Brand colours, CTA copy and end card
  • Size-budget and MRAID compliance report
  • Two size-reduction revisions
  • ZIP with index.html plus QA checklist

Variant Pack

$449 one-time

For Studio already running a UA test that needs A/B hooks

  • One mechanic template
  • Three hook variants in one export
  • Per-variant size-budget and MRAID report
  • Two size-reduction revisions per variant
  • ZIP with all index.html files plus QA checklist

Model: One-time per-artifact purchase, paid before generation, with an optional larger bundle for A/B testing.

First revenue offer: A free, finished playable for their game with the compliance report attached, then: 'Three hook variants of the same playable for $449, or one for $199 — both uploadable this week.'

Expected ACV: $224

Upsell path: Free sample to $199 single playable, then $449 variant pack once the first hook has data, then repeat purchases each time the studio launches a title or opens a new network.

Target customers
25
Revenue model
$4,975
Costs
$210
Profit model
$4,765
Section 4 of 8

First-customer acquisition

Primary channel

Manual generation of a free, finished playable sample for recently launched indie casual games, sent to the listed developer directly.

Where to find them

  • App Store and Play Store new-release lists filtered to casual, hyper-casual and puzzle
  • Store listings whose developer name is a person or a one-product studio with no publisher
  • r/gamedev and r/AndroidGaming threads where developers ask about UA creative
  • Indie mobile Discord and Slack communities with user-acquisition channels
  • X accounts posting about Meta or AppLovin creative tests
  • Product Hunt and itch.io mobile launches from the last 90 days

Exact outreach motions

  • Build a 100-row list of qualifying studios with game name, store URL, icon and screenshot URLs, plus a contact handle or store-listing email
  • Generate a free 15-second playable for the first 20 and attach the size-budget and timing report
  • Send the file with a one-line message and no ask beyond a reply
  • Four days later, follow up once with a second variant or a note on which screenshot made the strongest opening frame
  • Post a build-in-public thread in r/gamedev showing the size meter and a before/after of an oversized hand-coded file
  • DM 10 indie developers per day on X with their own generated sample attached

Message template

Hey — I made a playable ad for <Game> in about 10 minutes. It's under 5MB, MRAID 2.0 wrapped, CTA routes to your store listing, and first tap lands at 1.4s. The file is attached plus a size and compliance report. No strings, no signup — if you want three hook variants to A/B test it's $449, single is $199. Want me to change the opening frame?
Week-one goal: 100-row qualified list built and 10 free finished playables sent to named developers with the compliance report attached.
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

Ship the skeleton and payment rails

  • Scaffold Next.js with TypeScript and deploy to Vercel on a bought domain
  • Open and connect the Stripe account to TrustMRR before any customer exists
  • Create the R2 bucket and Resend domain, store keys in Vercel env

Deliverable: Live deployed skeleton with working payment and storage credentials.

Day 2Template runtime

One config schema, one drawing loop

  • Define the JSON config schema for mechanic, colours, copy and asset slots
  • Build the shared canvas runtime and HTML shell
  • Render a hardcoded tap-to-collect demo in the browser

Deliverable: Working template renderer with a hardcoded config.

Day 3MRAID wrapper

Make the file network-safe

  • Add the MRAID 2.0/3.0 script with isViewable gating
  • Wire CTA clickthrough and the App-Store-style end card
  • Assert zero external network requests in the compiled file

Deliverable: A playable that opens correctly in the MRAID test harness.

Day 4Asset pipeline

Fit under 5MB without wrecking art

  • Build Sharp crop to template slot dimensions
  • Implement the compression ladder with quality steps
  • Show a live size-budget meter in the builder

Deliverable: Upload icon and screenshots, see remaining MB update live.

Day 5ExportMVP shipped

Deliver a real artifact

  • Compile to a single index.html with everything inlined
  • ZIP to R2 and generate a signed URL
  • Email the link via Resend on a manual test order

Deliverable: MVP complete: a paid-for ZIP is generated and emailed.

Day 6Live payments

Pay-first, no accounts

  • Switch Stripe to live mode and build the Checkout session
  • Handle the webhook to trigger compile and delivery
  • Run one real end-to-end purchase with a real card

Deliverable: Verified live purchase to delivered ZIP.

Day 7Mechanics 2-3

Broaden the template set

  • Build the dodge-runner template
  • Build the merge-two template
  • Add the Playwright first-interaction timing check

Deliverable: Three mechanics plus automated timing report.

Week 2 · Launch & first sale · 7 days
Day 8Mechanics 4-5 and variants

Complete the five and the A/B export

  • Build slice-swipe and idle-tapper templates
  • Add the variant generator producing three hook edits
  • Render per-variant size reports into the ZIP

Deliverable: Five mechanics and a working variant pack export.

Day 9Landing page

Make the offer legible in 20 seconds

  • Publish the landing page with two live sample previews
  • State exact pricing, refund policy and delivery time
  • Add the download QA checklist to every export

Deliverable: Public site with samples, pricing and policy.

Day 10Prospect list

Build the 100-row pipeline

  • Scrape App Store and Play new releases for casual and puzzle titles
  • Filter out anything with a publisher or in-house UA team
  • Record game, icon, screenshot URLs and a reachable contact

Deliverable: 100-row qualified prospect sheet.

Day 11Samples

Send the first finished files

  • Generate five free playables from public store assets
  • Attach the size-budget and timing report to each
  • Send with the one-line message, no signup link

Deliverable: Five finished samples sent to named developers.

Day 12Samples at volumeFirst sale target

Reach the daily quota

  • Generate and send five more free playables
  • DM ten indie developers on X with their own sample
  • Post a build-in-public thread in r/gamedev

Deliverable: First paid order target day and 10 samples out.

Day 13Follow-up

Recover the non-repliers

  • Follow up day-11 recipients with a second variant
  • Answer every reply within two hours
  • Log objections in one sheet for the week-3 fixes

Deliverable: Objection log and second-touch sent.

Day 14Convert

Turn interest into revenue

  • Send Checkout links to respondents and close the first sales
  • Fix the top onboarding friction found in replies
  • Publish the refund and revision policy

Deliverable: First verified revenue inside the hackathon window.

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

Five samples a day

  • Generate and send five samples
  • Extend the prospect list toward 100 rows
  • Publish the QA checklist as a standalone page

Deliverable: 15 cumulative samples sent.

Day 16Communities

Be useful in public

  • Answer UA creative threads in indie mobile Discords
  • Post the size-meter before/after in two gamedev communities
  • Capture every inbound question as a landing-page FAQ item

Deliverable: Community posts live and FAQ updated.

Day 17Upsell

Move single buyers to variant packs

  • Email every free-sample recipient the $449 variant offer
  • Add variant pack to the Checkout success page
  • Show a three-file preview of a variant pack

Deliverable: Upsell sequence sent to all recipients.

Day 18Speed

Cut generation to ten minutes

  • Add genre presets for the top three prospect categories
  • Automate icon fetch and auto-crop from a pasted store URL
  • Measure median time from paste to sent sample

Deliverable: Store URL to finished sample under ten minutes.

Day 19Compliance proof

Make rejection unlikely

  • Add a per-export MRAID version and tap-target report
  • Verify all five templates under 5MB with worst-case assets
  • Document the end-card elements each network requires

Deliverable: Compliance report shipped inside every ZIP.

Day 20Proof artifacts

Show the work without inventing customers

  • Publish three self-generated sample playables as a public gallery
  • Post the file-size and timing numbers for each
  • Remove any wording that implies existing customers

Deliverable: Public sample gallery with measured numbers only.

Day 21Midpoint review

Double down on what converts

  • Compute reply rate, sample-to-paid rate and best-performing message
  • Cut the two worst-performing mechanics from the default list
  • Rewrite the message using the winning opening line

Deliverable: Ranked channel and message decision for week 4.

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

Raise output without raising hours

  • Batch-generate ten samples in one session
  • Reuse the three winning genre presets
  • Queue sends across two days

Deliverable: Ten samples generated in one sitting.

Day 23Outreach cadence

Ten messages a day

  • Send ten personalized samples or DMs
  • Track replies in the same sheet as revenue
  • Flag any studio that opened twice and did not reply

Deliverable: Daily cadence running with reply tracking.

Day 24Support guardrails

Protect the solo hours

  • Cap each order at two size-reduction revisions
  • Publish a plain-language support FAQ and response window
  • Template the three most common revision replies

Deliverable: Support policy live and replies templated.

Day 25Organic listings

Free durable inbound

  • Submit to indie game dev newsletters and tool directories
  • Post a size-budget teardown to a gamedev community
  • Add a shareable preview link per exported playable

Deliverable: Two organic listings submitted with preview links.

Day 26Repeat revenue

Sell a second artifact

  • Offer prior buyers a second mechanic at the same price
  • Pitch variant packs to anyone who only bought one file
  • Ask each buyer which network they uploaded to

Deliverable: Repeat-purchase offer sent to all buyers.

Day 27Quality pass

Make the file stronger than the price

  • Trim the worst-rated template until first tap is under 1.5s
  • Re-check all five templates at worst-case asset weight
  • Fix the top three revision requests

Deliverable: All templates re-verified under size and timing limits.

Day 28Sprint

Final volume push

  • Send 20 messages across X and store-listing contacts
  • Follow up every day-22 recipient once
  • Answer all outstanding threads same-day

Deliverable: 20 fresh outreach touches sent.

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

Convert the remaining pipeline

  • Send a last-call note with a fresh variant attached
  • Offer the variant pack at the single price for today only
  • Confirm every buyer can upload inside the window

Deliverable: Close sequence sent to all warm prospects.

Day 30Reconcile

Verify the number

  • Reconcile Stripe payouts against TrustMRR records
  • Process any refunds and record chargebacks
  • Publish collected revenue, fees and hackathon profit

Deliverable: Verified profit figure submitted before the deadline.

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 case: 100 personalized free samples produce roughly 12 paid orders, a 12% sample-to-paid rate.
  • Blended ARPU rises above $199 because a share of buyers upgrade to the $449 variant pack.
  • Payment fees assume Stripe at roughly 2.9% plus $0.30 per transaction, modelled at 4.2-5.0% of gross.
  • No paid marketing in Conservative and Base because outreach is manual and organic.
  • Upside includes $250 of paid spend on promoted posts and creator shout-outs, which is deducted from hackathon profit.
  • Operating costs cover Vercel, domain, R2 storage, Resend and per-order LLM copy suggestions; they are excluded from hackathon profit by rule.
  • Refunds stay under 6% because buyers preview the playable before paying.
  • Every sale clears its own delivery cost, so no order is sold below cost.

Conservative

4 customers
$796
collected revenue · avg payment $199
Refunds
$40
Chargebacks
$0
Payment fees
$33
Paid marketing
$0
Hackathon profit
$723
Operating costs
$35
Business profit
$688

Base case

12 customers
$2,688
collected revenue · avg payment $224
Refunds
$108
Chargebacks
$0
Payment fees
$121
Paid marketing
$0
Hackathon profit
$2,459
Operating costs
$85
Business profit
$2,374

Optimistic

26 customers
$6,708
collected revenue · avg payment $258
Refunds
$200
Chargebacks
$0
Payment fees
$285
Paid marketing
$250
Hackathon profit
$5,973
Operating costs
$160
Business profit
$5,813

Model your own numbers

Runs in your browser · nothing is saved
Collected revenue
$2,388
Payment fees (3.9%)
$93
Paid marketing
$0
Hackathon profit
$2,295
Business profit
$2,210

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 traction.

Section 7 of 8

Main risks and validation experiments

Risk 1Studios ignore free cold samples because the sender has no reputation.

Mitigation

Lead with the finished file and measured numbers, ask nothing in the first message, and make the sample usable without signup.

Validation experiment

Send 20 samples over three days and count opens and replies before writing any sales copy.

Kill criteria

Fewer than 2 replies from 40 samples means the channel or the artifact is wrong; switch to community-led inbound or change the mechanic set.

Risk 2Ad networks reject the exported file for size, MRAID version or a missing end-card element.

Mitigation

Ship a per-export compliance report, verify every template at worst-case asset weight, and document each network's end-card requirements.

Validation experiment

Upload one self-generated playable to Meta and one to AppLovin in a live or sandbox campaign and record the review outcome.

Kill criteria

Two rejections on the same template mean the wrapper is not trustworthy; stop outreach until it passes.

Risk 3Template mechanics look generic and produce weak real-world click-through, killing word of mouth.

Mitigation

Tune the opening frames per genre and give every buyer a fast way to request a different first frame.

Validation experiment

Ask three buyers to report the first three days of network CTR on the delivered file.

Kill criteria

If reported CTR sits below the buyer's existing static creative, retire that template and rebuild the opening hook.

Risk 4Generating samples from a studio's public icon and screenshots reads as IP overreach.

Mitigation

Use only publicly listed store assets, generate on request for anyone who objects, and delete any sample on request.

Validation experiment

Track objections for the first 20 messages and count any that cite asset use.

Kill criteria

Any explicit objection from two or more studios means switching to an opt-in 'generate mine' link instead of unsolicited files.

Risk 5Support and revision requests consume the build window.

Mitigation

Cap revisions at two per order, template the common replies, and publish a response window.

Validation experiment

Log minutes per order for the first ten orders.

Kill criteria

Anything over 45 minutes average per order means the config surface is too wide; cut options.

Section 8 of 8

Hour-by-hour: the first 24 hours

Hours 1-2

  • Create the repo and scaffold Next.js with TypeScript
  • Buy the domain and deploy the skeleton to Vercel
  • Confirm the contest start time and rule page URL are bookmarked

Output: Deployed empty app on a live domain.

Hours 3-5

  • Open the Stripe account and connect it to TrustMRR
  • Create the R2 bucket and Resend sending domain
  • Store every key in Vercel env vars and verify all three connections

Output: Payment, storage and email rails connected before any customer exists.

Hours 6-9

  • Write the template config schema
  • Build the canvas runtime and HTML shell
  • Render a hardcoded tap-to-collect screen in the browser

Output: First mechanic rendering from a JSON config.

Hours 10-13

  • Add the MRAID script and isViewable gating
  • Wire CTA clickthrough and the end card
  • Confirm the file makes zero external network calls

Output: A single HTML file that opens correctly in an MRAID harness.

Hours 14-16

  • Draft the 100-row prospect sheet structure
  • Collect five new-release casual games with reachable contacts
  • Write the first outreach message verbatim

Output: Five-row seed list and the first message ready to send.

Complete report

Full 30-day launch report

Read the full generated report

Hookframe — 30-Day Launch Report

1. Product opportunity and positioning

Playable ads are the one mobile creative where the user has already played the game before installing. For a 1-10 person casual, hyper-casual or puzzle studio running a Meta, AppLovin or TikTok test, playables usually carry the strongest intent of any asset — and the studio still cannot make one.

The blocker is engineering, not taste. A hand-coded playable must inline every image as base64 to survive a hard file-size ceiling, wrap itself in MRAID so the network can call isViewable, route the CTA to the store listing, and reach first interaction in a couple of seconds. That is a multi-day detour for a team whose only developer is shipping the game. So the studio skips playables or pays an agency several hundred to a few thousand dollars with a one-to-two-week turnaround.

Hookframe collapses that to a website and a ZIP: five parameterized mechanics, an icon and two or three screenshots in, one self-contained index.html out, with a size-budget report, a measured time-to-first-interaction, and a one-page upload checklist. A variant pack exports three hook edits for A/B testing.

The positioning stays narrow on purpose. Hookframe is not a creative platform, not a network integration, not a game engine. It is a per-artifact purchase for a buyer with a live campaign, priced below one agency day-rate so it clears a card without procurement. The deliverable is inspectable in a minute and uploadable the same day, so the sales cycle is hours.

Three things make this sellable solo. The buyer is directly reachable, because indie games are publicly listed and new-release lists are a rolling supply of studios that just launched and now need traffic. The objection that kills DIY — "it gets rejected" — is answered by a document rather than by trust. And the trigger is a calendar event, so timing does the qualifying instead of a brand.

The weakness is honest: template mechanics are copyable. The defensible part is the compliance pack and the speed of delivery, and the real business is the repeat purchase every time the same studio launches a title or opens a new network.

2. Smallest sellable MVP

One page, five mechanics, one payment. The buyer selects a mechanic, uploads an icon and screenshots, sets colours and copy, pays $199 on Stripe Checkout, and receives an emailed signed link to a ZIP containing index.html, the size report and the QA checklist. No account, no dashboard, no login. That is the entire product on day 5; everything else is iteration.

3. Technical implementation plan

Next.js on Vercel renders the builder. A compile endpoint takes a JSON config and runs a vanilla canvas template — no Phaser runtime, because the payload budget is the constraint. Sharp crops each image to the slot dimensions and walks a compression ladder until the inlined total sits under 5MB. Playwright loads the compiled file headlessly to record time-to-first-interaction and assert zero external requests before the ZIP is sealed. The ZIP lands in R2 under a random key; Stripe's webhook marks the order paid, then Resend emails a signed, time-limited URL. One LLM call drafts three CTA lines; it never touches the delivery path.

The single thing most likely to break is the compression ladder — fitting real screenshots under 5MB without destroying them, at every template, at worst-case asset weight.

4. Pricing and monetization

Two one-time products. Single Playable at $199, Variant Pack at $449 for three hook edits with per-variant reports. Both sit under one agency day-rate, which is the approval threshold that matters. Movement from a free sample to $199, then to $449 once the first hook has data, then a repeat purchase on the next launch. No subscription in the first 30 days: a monthly charge on an occasional need creates churn and refunds.

5. First-customer acquisition

The only channel is the free finished sample. Build a 100-row list from App Store and Play Store new releases, filtered to solo developers and one-product studios with no publisher. For the first twenty, generate a complete playable from public store assets and send the file with its compliance report, asking for nothing but a reply. Follow up once after four days with a second variant. In parallel, DM ten indie developers a day on X, and post the size-meter before/after in r/gamedev. Five samples a day is the working quota.

6. Execution roadmap

Days 1-7 build the core: payments and storage rails, the template runtime, the MRAID wrapper, the asset pipeline and the live export, ending with a real card purchase and a delivered ZIP on day 6, then two more mechanics and the timing check. Days 8-14 finish all five mechanics, ship the variant generator and the public site, build the 100-row list, and start sending samples on day 11 with a first paid-order target of day 12. Days 15-21 raise volume to five samples a day, work the gamedev communities, push the $449 upsell to every sample recipient, automate store-URL-to-sample under ten minutes, and publish a public sample gallery using only self-generated files with measured numbers. Day 21 is the midpoint review: reply rate, sample-to-paid rate, and the winning message. Days 22-28 run the cadence at ten messages a day, cap revisions at two per order, submit to organic directories, sell second artifacts to existing buyers, and re-verify every template against the size and timing limits. Days 29-30 close warm prospects and reconcile Stripe payouts against TrustMRR so the submitted profit number is verified rather than estimated.

7. Revenue and profit scenarios

All three cases below are projections from stated assumptions. They are not verified revenue, not existing customers, and not traction.

Conservative assumes 4 orders at $199 with no paid marketing. Base assumes 12 orders at a $224 blended ARPU as some buyers upgrade to the variant pack. Upside assumes 26 orders at $258 blended, with $250 of paid promotion that is deducted from hackathon profit.

Hackathon profit is collected revenue minus refunds, chargebacks, payment fees and paid marketing spend; hosting, domains, tooling and LLM delivery costs are excluded from that figure by rule but are still real and are carried in operating costs for business profit. In the base case, gross revenue of $2,688 less $108 refunds, $121 in processing fees and zero ad spend leaves $2,459 of hackathon profit, and $2,374 after $85 of operating costs. Every order clears its own delivery cost, so nothing is sold below cost.

8. Main risks and validation experiments

Cold samples from an unknown sender may be ignored. Test with 20 sends and count replies before writing sales copy; fewer than two replies from 40 sends means the channel or the artifact is wrong. Network rejection is the second risk — mitigated by a per-export compliance report and a live upload test to Meta and AppLovin in the first two weeks; two rejections on one template stops outreach. Generic-looking mechanics are the third: ask three buyers for their first three days of CTR and retire any template that underperforms their existing statics. IP overreach is real: use only public store assets, delete on request, and switch to an opt-in "generate mine" link if two studios object. Support load is the fifth: log minutes per order and cut config options if the average passes 45 minutes.

9. First 24-hour action plan

Hours 1-2: repo, domain, deployed skeleton. Hours 3-5: Stripe connected to TrustMRR, R2 bucket, Resend domain, all keys in Vercel — the payment rails exist before any customer does. Hours 6-9: config schema, canvas runtime, one hardcoded mechanic rendering. Hours 10-13: MRAID script, isViewable gating, CTA clickthrough, end card, and a verified zero-external-request file. Hours 14-16: prospect sheet structure, five new-release games with contacts, and the outreach message written verbatim.

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 →