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.
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.
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.
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.
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.
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)
- Buyer opens the Hookframe landing page and clicks Preview on a sample playable
- Buyer picks one mechanic and uploads icon plus two screenshots
- Buyer sets brand colours, CTA copy and end-card headline; the size meter updates live
- Buyer clicks Buy, pays $199 on Stripe Checkout
- Webhook compiles the artifact, stores the ZIP, and emails a signed download link
- Buyer opens the ZIP, reads the size-budget and timing report, uploads index.html to Meta
Technical implementation plan
Stack
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
- Day 1: scaffold Next.js, domain, Vercel deploy, Stripe account connected to TrustMRR, repo and env vars
- Day 2: define the template config schema and build the shared canvas runtime plus HTML shell
- Day 3: implement the MRAID 2.0/3.0 wrapper, isViewable gating, CTA clickthrough and end card
- Day 4: build the Sharp asset pipeline with a compression ladder and the live size-budget meter
- Day 5: wire the export to a single index.html, ZIP it to R2, and email the signed link via a manual test order
- Day 6: switch Stripe to live mode, verify the pay-first to delivery flow end to end with a real card
- Day 7: add the remaining four mechanics and the Playwright timing and network-isolation check
- Day 8: add the variant generator that renders three hook edits into one ZIP
- 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
Pricing and monetization
Single Playable
Entry offerFor 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
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.
First-customer acquisition
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?
30-day execution roadmap
Week 1 · Build & validate · 7 days
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.
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.
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.
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.
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.
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.
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
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.
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.
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.
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.
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.
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.
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
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.
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.
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.
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.
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.
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.
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
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.
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.
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.
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.
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.
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.
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
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.
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.
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- Refunds
- $40
- Chargebacks
- $0
- Payment fees
- $33
- Paid marketing
- $0
- Hackathon profit
- $723
- Operating costs
- $35
- Business profit
- $688
Base case
12 customers- Refunds
- $108
- Chargebacks
- $0
- Payment fees
- $121
- Paid marketing
- $0
- Hackathon profit
- $2,459
- Operating costs
- $85
- Business profit
- $2,374
Optimistic
26 customers- 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.
Main risks and validation experiments
Risk 1Studios ignore free cold samples because the sender has no reputation.
Lead with the finished file and measured numbers, ask nothing in the first message, and make the sample usable without signup.
Send 20 samples over three days and count opens and replies before writing any sales copy.
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.
Ship a per-export compliance report, verify every template at worst-case asset weight, and document each network's end-card requirements.
Upload one self-generated playable to Meta and one to AppLovin in a live or sandbox campaign and record the review outcome.
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.
Tune the opening frames per genre and give every buyer a fast way to request a different first frame.
Ask three buyers to report the first three days of network CTR on the delivered file.
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.
Use only publicly listed store assets, generate on request for anyone who objects, and delete any sample on request.
Track objections for the first 20 messages and count any that cite asset use.
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.
Cap revisions at two per order, template the common replies, and publish a response window.
Log minutes per order for the first ten orders.
Anything over 45 minutes average per order means the config surface is too wide; cut options.
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.
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 →Quote60 Trades
Talk through a job for 60 seconds and get a branded, line-item PDF quote you can text the customer before you leave the driveway.
PatchNote Reel
Turns a Steam patch-notes changelog into a 20-second captioned vertical video for TikTok and Shorts, aimed at solo indie devs.
MumbleBrief
A browser-based recorder that turns a 60-second spoken client update into a formatted, send-ready project status email.