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

DemoDrift

Automated regression testing for interactive product demos that replays each step against the live app and delivers a broken-step report before prospects see it.

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

Decide in 20 seconds

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

Speculative5.76/10
MVP build (solo)
5 days
Launch price
$99
Sales to $1,000 revenue
11 customers
First paying customer
Founder-led public demo teardown: find B2B SaaS companies with public interactive demos, scan one for free, and send the finished broken-step report to the demo owner.
Who pays

Marketing operations manager or sales-enablement lead at a 50-250 person B2B SaaS that publishes 5+ Storylane/Navattic/Walnut demos and ships product UI weekly, acting on a release or campaign-launch trigger in the US, UK or Canada.

Biggest execution risk

Market demand 3.2/10

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

Why this could work in 30 days: one founder can ship the MVP in 5 days; the plan targets a first sale on day 12; 11 sales at $99 clears $1,000 of collected revenue; strongest signal is speed to first revenue at 8.4/10.

Score and projections come from the generated report and are not guarantees. The $100K Hackathon is run by Ship or Die — read the official rules before you build.

Your first 24 hours

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

0/15
Entry price
$99
Solo build
5 days
30d base revenue
$1,400
30d hackathon profit
$1,352
Section 1 of 8

Product opportunity and positioning

Target customer

Marketing operations manager or sales-enablement lead at a 50-250 person B2B SaaS that publishes 5+ Storylane/Navattic/Walnut demos and ships product UI weekly, acting on a release or campaign-launch trigger in the US, UK or Canada.

Why now

B2B SaaS teams now publish interactive demos as a primary conversion asset while shipping UI weekly, so demo decay is a recurring, dated event rather than a one-off, and the resulting report is urgent enough to buy without procurement.

Problem

Interactive demos silently drift after UI releases: hotspots break, screenshots go stale and pricing copy goes wrong, but nobody owns re-testing the demo before prospects see it.

Solution

Submit the demo URL plus the live app URL; DemoDrift replays the step sequence in a headless browser, snapshots screenshot, DOM selector and visible text per step, diffs against the current app, and delivers a shareable HTML/PDF Demo Health Report with severity, exact broken step and a suggested fix.

Differentiation · Demo builders sell creation; DemoDrift sells maintenance. The output is a forwardable artifact with a severity-ranked broken step and a screenshot diff, not another authoring canvas or a Loom recording.

DemoDrift — Product Opportunity and Positioning

Interactive demos are sold as set-and-forget assets. They are not. A B2B SaaS that ships weekly changes navigation, renames buttons, moves the pricing page and relabels dashboard columns; the demo built three months ago keeps replaying the old screen. Hotspots stop lighting up, the tour stalls on a step that no longer exists, and the prospect leaves without telling anyone. Nobody owns the check: marketing owns the demo, product owns the release, and the gap between them is where DemoDrift lives.

The buyer is a marketing operations manager or sales-enablement lead at a 50-250 person B2B SaaS publishing five or more Storylane, Navattic or Walnut demos and shipping UI weekly. The trigger is concrete — a release or a campaign launch — so the sale closes without a procurement cycle. DemoDrift is not a demo builder. It is regression testing for demos that already exist: submit a public demo URL and the live app URL, receive a report that names the exact broken step, shows the screenshot diff and suggests a selector or screenshot replacement.

The narrowness is deliberate. JEV scored this concept 57.6/100, band C, confidence 0.69. The strongest sub-score is speed to first revenue (8.42): the free scan is simultaneously the pitch, the proposal and the proof. The weakest are market demand (3.17) and operational simplicity (4.91). Both are attacked the same way — pin the buyer to the release-trigger segment so the problem is dated and budgeted, and keep delivery stateless: one managed browser, one managed database, no human review step in the delivered report.

The generic alternatives are a manual monthly click-through (unowned, unscoped, produces no artifact) and a screen recording (not clickable, not diffable). The wedge is that the output is forwardable. A marketing ops lead can attach a DemoDrift report to a launch checklist and hand it to whoever edits the demo. That is the distribution mechanism: every report sent is also a fix ticket, and every fix ticket names the product.

Positioning statement: for B2B SaaS teams whose public demos outlive their UI, DemoDrift is the release-time demo check that returns a broken-step report in minutes, priced per audit rather than per seat.

Section 2 of 8

Smallest sellable MVP

A paid page where a buyer pastes a public demo URL and a live app URL, receives an emailed HTML report naming each broken step with a screenshot diff and a suggested fix, charged $99 through Stripe Checkout.

Must-have features

  • URL intake form with demo URL, live app URL and contact email
  • Job queue row per scan with status polling
  • Playwright runner that advances the demo's hotspot sequence and captures one snapshot per step
  • Per-step capture of screenshot, DOM selector list and visible text
  • Diff engine combining pixelmatch, selector-presence checks and text-similarity scoring
  • Severity ranking (blocker, major, minor) with the exact failing step number
  • Shareable HTML report at a stable public link plus a PDF export
  • Stripe Checkout for one-time audit and release pack
  • Minimal dashboard listing past scans and their report links

Explicitly out of scope

  • Demo authoring or editing environment
  • Transcript-based personalization or AI sales engineer features
  • Chrome extension or DOM capture browser plugin
  • CI/CD or GitHub integration
  • Automatic fix deployment into Storylane, Navattic or Walnut
  • Team seats, roles, SSO or enterprise contracts
  • Scheduled monitoring before day 16
  • Support SLA or 24/7 availability promise

Demo flow (what the buyer sees)

  1. Buyer lands on demoddrift landing page and clicks Run a Demo Health Check
  2. Pastes the public demo URL and the live app URL, enters email, pays $99 via Stripe Checkout
  3. Job is queued; the Playwright runner loads the demo and walks the hotspot sequence step by step
  4. Each step stores a screenshot, matched DOM selectors and visible text
  5. The diff engine compares step snapshots with the live app and scores each mismatch by severity
  6. The report renders at a public link and is emailed as HTML with a PDF attachment
  7. Buyer forwards the report to the demo owner, fixes the flagged steps, optionally buys a $249 Release Pack
Build plan

Technical implementation plan

Stack

Next.js on VercelPlaywrightBrowserless.ioSupabase PostgresStripe CheckoutResendpixelmatchpdf-lib

Architecture

A Next.js app on Vercel serves the landing page, intake form and report pages. Submitting a scan inserts a row into Supabase and immediately hands off to a background function that opens a Browserless session, drives Playwright through the demo's hotspot sequence, and writes one snapshot row per step. A second pass visits the live app URL, and the diff worker compares stored snapshots against it using pixelmatch for image deltas, selector-presence checks for broken hotspots, and text similarity for stale copy. Results are written back as severity-ranked issues; the report route renders them as static HTML and pdf-lib produces the export. Resend delivers the email. Stripe Checkout creates the charge before the scan is allowed to run.

Build steps

  1. Create the Vercel project with a landing page, intake form and a health endpoint
  2. Define Supabase tables: scans, steps, issues, reports
  3. Wire Stripe Checkout so a paid session creates the scan row
  4. Build the Browserless + Playwright runner and get it to advance one real public demo
  5. Add per-step capture of screenshot, selector list and visible text
  6. Implement the diff engine with pixelmatch thresholding plus selector and text checks
  7. Add severity scoring rules and suggested-fix text generation
  8. Render the public HTML report route and the PDF export
  9. Send the report email through Resend with the link and PDF attached
  10. Add the dashboard listing past scans by email
  11. Add the release pack flow: one checkout, three scan slots
  12. Harden error paths so a failed scan returns a free rerun instead of a silent failure

AI components

  • A single LLM call that turns a detected diff into a plain-language suggested fix (selector replacement or screenshot refresh instruction)
  • An optional LLM pass that classifies whether a text delta is cosmetic or materially wrong (pricing, plan names, feature labels)
Hardest technical risk: Many demo platforms render tours inside an iframe with a proprietary player, so a generic 'follow the hotspot sequence' runner may not work on every platform. Test 20 real public demos on days 1-2 before investing in the diff engine.
Section 3 of 8

Pricing and monetization

Single Demo Audit

Entry offer
$99 one-time

For Marketing ops lead with one critical public demo

  • 1 demo scan
  • HTML/PDF health report
  • 3 suggested fixes

Release Pack

$249 one-time

For Team shipping a release or campaign with multiple demos

  • 3 demo scans
  • Prioritized broken-step report
  • CSV issue export

Monthly Watch

$199 / month

For Demo owner with 5+ demos who ships weekly

  • 5 demos checked weekly
  • Email alerts on new breaks
  • Monthly health report

Model: One-time audits and release packs as the primary revenue, with an optional monthly watch subscription for repeat demo owners.

First revenue offer: A free DemoDrift scan of the prospect's public demo, sent as a finished report with one named broken step and a screenshot diff, followed by: 'If this is useful, the $99 Single Demo Audit covers a full pass on this demo with suggested fixes; the $249 Release Pack covers three demos before your next launch.'

Expected ACV: $140

Upsell path: Audit buyers convert to Release Packs before their next release; Release Pack buyers convert to Monthly Watch at $199/month once they ship more than once a quarter. Each report is forwarded internally, which creates a second named buyer without extra acquisition spend.

Target customers
60
Revenue model
$14,940
Costs
$900
Profit model
$14,040
Section 4 of 8

First-customer acquisition

Primary channel

Founder-led public demo teardown: find B2B SaaS companies with public interactive demos, scan one for free, and send the finished broken-step report to the demo owner.

Where to find them

  • Storylane, Navattic and Walnut public demo gallery and showcase pages
  • 'Book a demo' and 'See it in action' pages on B2B SaaS marketing sites that embed an interactive tour
  • G2 and Capterra review pages that link to an interactive product tour
  • LinkedIn posts announcing a new interactive demo or a product launch
  • Product Hunt launches in B2B SaaS that publish an interactive tour
  • Company changelog and release-note pages, filtered to teams shipping weekly

Exact outreach motions

  • Build a 60-row list with company, demo URL, demo owner name and contact
  • Scan one demo per account and only send where a real break is found
  • Send a 90-word email naming the exact step number and the visible difference
  • Attach the report as a PDF and link the hosted HTML version
  • Follow up once after 48 hours with the screenshot of the diff, not a generic nudge
  • Offer the paid audit only after the free report lands, never in the first line

Message template

Subject: Step 3 of your public demo looks stale

Hi {first_name} — I ran a check on your public demo at {demo_url} against {app_url}. Step 3 ('{step_label}') still shows the old navigation, and the hotspot on step 5 no longer resolves. Screenshot diff and the full step list are in the report: {report_link}.

No pitch attached — I built a scanner that replays demos and flags drift after releases. If it's useful I can run a full pass on the other demos before your next launch.
Week-one goal: 60 accounts listed, 25 free teardown reports delivered, 3 replies, 1 Stripe checkout started.
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 1Feasibility

Prove Playwright can replay public demos

  • Collect 20 public demo URLs across Storylane, Navattic and Walnut.
  • Run a throwaway Playwright script against 5 and log whether hotspot sequences are replayable.
  • Record which platforms render inside an iframe or block headless browsers.

Deliverable: Platform feasibility sheet marking each demo replayable, partial or blocked.

Day 2Scaffold

Stand up the app shell and data model

  • Create the Next.js project on Vercel with the intake form.
  • Define Supabase tables for scans, steps, issues and reports.
  • Wire Stripe test-mode checkout to create a scan row.

Deliverable: Deployed skeleton where a form submission creates a queued scan.

Day 3Runner

Capture steps reliably

  • Integrate Browserless and get Playwright to advance one full demo sequence.
  • Store screenshot, selector list and visible text per step.
  • Add retry and timeout handling for slow demo players.

Deliverable: Runner producing complete step snapshots for one real demo.

Day 4Diff engine

Turn snapshots into severity-ranked issues

  • Implement pixelmatch image comparison with a tuned threshold.
  • Add selector-presence and text-similarity checks per step.
  • Score each issue as blocker, major or minor and attach a suggested fix.

Deliverable: Severity-ranked issue list generated for three real demos.

Day 5MVP deadlineMVP shipped

Ship the paid path end to end

  • Render the public HTML report route and the PDF export.
  • Enable Stripe live mode and test one real $99 charge with a refund.
  • Send the report email through Resend and confirm delivery.

Deliverable: Live product: URL in, $99 charged, report emailed.

Day 6Outreach prep

Build the target list

  • Compile 60 accounts with public demos and weekly release cadence.
  • Identify the marketing ops or sales-enablement owner per account.
  • Find a direct email or LinkedIn profile for each.

Deliverable: 60-row outreach spreadsheet with demo URL, owner and contact.

Day 7First sends

Deliver free teardowns

  • Run free scans on 10 accounts and keep only those with a real break.
  • Send 10 personalized teardown emails with the report link.
  • Log send time, step flagged and channel used.

Deliverable: 10 free Demo Health Reports delivered.

Week 2 · Launch & first sale · 7 days
Day 8Follow-up

Recover replies

  • Follow up on day-7 sends after 48 hours with the diff screenshot.
  • Tune the message subject line based on opens.
  • Reply to every response within two hours.

Deliverable: Follow-up log with open and reply counts.

Day 9Volume

Extend the list and send

  • Add 20 more accounts from demo galleries and launch posts.
  • Send 15 more teardown emails.
  • Offer the $99 audit to anyone who replied positively.

Deliverable: 25 total teardowns sent, 3 checkout links issued.

Day 10Objections

Learn why people say no

  • Run calls with every responder who agrees to talk.
  • Record objections verbatim: price, ownership, trust in the report.
  • Fix the two cheapest objections in the landing copy.

Deliverable: Objection list with landing-page edits shipped.

Day 11Precision

Kill false positives

  • Re-scan 10 previously flagged demos and hand-verify each issue.
  • Raise the pixelmatch threshold until false positives drop.
  • Add a manual override to suppress known-cosmetic diffs.

Deliverable: Precision report: confirmed issues versus false positives.

Day 12First saleFirst sale target

Close the first paid audit

  • Send checkout links to all warm responders with a one-line deadline.
  • Offer to run the scan immediately on payment.
  • Confirm the Stripe charge lands in the connected account.

Deliverable: First verified paid customer and report delivered.

Day 13Volume

Send 20 more teardowns

  • Scan 20 new accounts and drop the ones with no break.
  • Send teardowns to the 12 with confirmed issues.
  • Log which demo platform produced the best hit rate.

Deliverable: 32 cumulative teardowns delivered.

Day 14Proof

Publish a public teardown

  • Write a short public teardown of an anonymized demo drift pattern.
  • Post it on LinkedIn with the before and after screenshot diff.
  • Link the post to the intake page.

Deliverable: One public teardown post published.

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

Push Release Packs

  • Offer the $249 Release Pack to every audit buyer.
  • Add a three-scan checkout variant in Stripe.
  • Ask each buyer to name the other demos they own.

Deliverable: Release Pack checkout live and offered to all buyers.

Day 16Monitoring

Ship the recurring tier

  • Add weekly re-scan scheduling for Monthly Watch customers.
  • Add an email alert when a new break appears.
  • Generate a monthly rollup report.

Deliverable: Monthly Watch at $199/month live and sellable.

Day 17Distribution

Content that carries the report

  • Post three concrete demo-drift examples on LinkedIn.
  • Comment on demo-launch posts with a specific observation, not a pitch.
  • Add the free scan button to the public teardown post.

Deliverable: Three posts live with a working intake link.

Day 18Volume

Send 25 more teardowns

  • Source 30 new accounts from release-note pages.
  • Run scans and send 25 reports with a named break.
  • Segment sends by demo platform to track hit rate.

Deliverable: 57 cumulative teardowns delivered.

Day 19Conversion

Tighten the paid path

  • Rewrite the checkout page to lead with the exact broken-step example.
  • Add a sample report behind a single click.
  • Remove every step between payment and report delivery.

Deliverable: Checkout page revision with a public sample report.

Day 20Recurring revenue

Convert buyers to Watch

  • Email every past buyer with the monthly option.
  • Offer a two-week trial scan on one extra demo.
  • Track which buyer types accept the subscription.

Deliverable: First Monthly Watch subscriber or a clear rejection signal.

Day 21Review

Measure the funnel

  • Tabulate scans sent, replies, checkouts, paid and refunded.
  • Kill the outreach variant with the worst reply rate.
  • Set the week-four send target from the best-performing segment.

Deliverable: Funnel table with conversion rates by segment.

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

Increase outreach throughput

  • Warm a second sending domain to protect deliverability.
  • Automate the list-to-scan intake so one founder can send 40 per day.
  • Cap sends at a level that keeps replies answerable.

Deliverable: Outreach system running at 40 teardowns per day.

Day 23Self-serve

Reduce founder involvement

  • Open a limited free scan (one demo, no PDF) to capture emails.
  • Gate the full report behind the $99 checkout.
  • Add an email capture on the free result page.

Deliverable: Self-serve free scan live with email capture.

Day 24Channel

Reach demo agencies

  • List boutique demo-building agencies and freelancers.
  • Offer them a white-label report at a fixed per-scan rate.
  • Send 10 agency-specific messages.

Deliverable: 10 agency conversations started.

Day 25Volume

Send 30 more teardowns

  • Scan 30 new accounts from Product Hunt launches.
  • Send reports to the 20 with confirmed breaks.
  • Follow up on the day-18 batch once.

Deliverable: 77 cumulative teardowns delivered.

Day 26Pricing

Test the pack

  • A/B the Release Pack price at $249 versus $349 on new sends.
  • Track checkout start rate per price.
  • Keep the winner and update the landing page.

Deliverable: Price test result recorded and applied.

Day 27Close

Convert the warm backlog

  • Send a direct close email to every unopened checkout.
  • Offer a same-day scan guarantee to remove delay.
  • Run scans the moment payment clears.

Deliverable: Warm backlog converted or explicitly closed.

Day 28Retention

Hold revenue

  • Check every delivered report for accuracy and re-issue any with errors.
  • Refund immediately where a report was wrong, and log the cause.
  • Ask each buyer for one forward to their demo owner.

Deliverable: Refund log and accuracy pass complete.

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

Last outreach wave

  • Send a final teardown wave to all untouched accounts.
  • Email every past buyer about the release-pack upsell.
  • Confirm Stripe payout timing lands inside the window.

Deliverable: Final outreach wave sent and payout timing confirmed.

Day 30Settle

Reconcile and submit

  • Reconcile charge count, refunds and fees against Stripe.
  • Verify each sale covered the delivery cost of that scan.
  • Submit the final revenue figures before the close.

Deliverable: Reconciled revenue report submitted.

Section 6 of 8

Revenue and profit scenarios

How the numbers are defined

Hackathon profit — Collected revenue − refunds − chargebacks − payment processing fees − paid marketing spend.

Business profit — Hackathon profit − operating costs (hosting, domains, tooling, AI/API delivery costs).

The contest ranks entrants on hackathon profit only. Hosting, tooling and AI/API delivery costs are not deducted by the organisers, but each sale still has to cover them — so we show both. Definitions verified on 2026-11-15 against the official rules.

Stated assumptions

  • Conservative: 3 paid audits at $99 — outreach reply rates below plan and the release-pack upsell does not land inside 30 days.
  • Base: 10 paying customers with a blended ARPU of $140, mixing audits and one or two release packs.
  • Upside: 22 paying customers with a blended ARPU of $165, which requires the teardown hit rate to hold above one confirmed break in three scans.
  • Payment processing assumed through Stripe at an effective 3.4% of collected revenue including the fixed per-charge component.
  • No paid marketing in conservative or base; the $150 in upside covers two sponsored newsletter placements.
  • Refunds are only modelled in upside, where volume makes at least one wrong report probable.
  • Operating cost covers Vercel, Supabase, Browserless browser minutes, Resend, a domain and LLM calls for suggested fixes — not deducted from hackathon profit.
  • All figures are projections built from stated assumptions, not observed revenue.

Conservative

3 customers
$297
collected revenue · avg payment $99
Refunds
$0
Chargebacks
$0
Payment fees
$10
Paid marketing
$0
Hackathon profit
$287
Operating costs
$25
Business profit
$262

Base case

10 customers
$1,400
collected revenue · avg payment $140
Refunds
$0
Chargebacks
$0
Payment fees
$48
Paid marketing
$0
Hackathon profit
$1,352
Operating costs
$60
Business profit
$1,292

Optimistic

22 customers
$3,630
collected revenue · avg payment $165
Refunds
$99
Chargebacks
$0
Payment fees
$124
Paid marketing
$150
Hackathon profit
$3,257
Operating costs
$140
Business profit
$3,117

Model your own numbers

Runs in your browser · nothing is saved
Collected revenue
$990
Payment fees (3.9%)
$39
Paid marketing
$0
Hackathon profit
$951
Business profit
$891

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.

These are scenario projections derived from the stated assumptions. They are not verified revenue, not existing customers and not a forecast of guaranteed outcome.

Section 7 of 8

Main risks and validation experiments

Risk 1Public demo URLs may not expose a reproducible step sequence, which would break the core scan.

Mitigation

Test 20 real demos across Storylane, Navattic and Walnut on days 1-2 and only claim support for platforms confirmed replayable.

Validation experiment

Run the throwaway Playwright script on 20 public demos and count how many advance through at least three steps.

Kill criteria

Abandon if fewer than 8 of 20 demos are replayable, or if all replayable demos come from a single platform with fewer than 20 scanned accounts.

Risk 2Reports produce false positives, so buyers distrust the artifact and refund.

Mitigation

Set a high pixelmatch threshold, require two independent signals (selector plus visual) before flagging a blocker, and hand-verify the first 30 reports.

Validation experiment

Hand-check 10 flagged issues against the live demo and record confirmed versus false positives.

Kill criteria

Pivot the deliverable to a manual-plus-tool audit if false positives exceed 30% of flagged blockers.

Risk 3Buyers treat demo QA as a free internal chore and refuse to pay $99.

Mitigation

Lead every message with a confirmed break rather than the product, and price the entry tier at one hour of the buyer's time.

Validation experiment

Send 25 free teardowns with a paid offer in the follow-up and measure checkout-start rate.

Kill criteria

If 60 teardowns produce zero checkout starts, re-price to $49 or move to a per-release subscription before day 20.

Risk 4Cold outreach deliverability and reply rates collapse, leaving no pipeline.

Mitigation

Cap sends per domain, warm a second domain from day 22, and shift volume to LinkedIn messages if email reply rate falls below 3%.

Validation experiment

Track reply rate per 25 sends and compare email against LinkedIn on the same list.

Kill criteria

Switch the primary channel if reply rate stays under 2% across 100 sends.

Risk 5Scanning public demos raises terms-of-service or privacy objections from the target.

Mitigation

Scan only publicly accessible demo URLs with no login, store no personal data, and delete screenshots on request.

Validation experiment

Ask each responder directly whether the scan felt acceptable and record the answers.

Kill criteria

Stop the free-scan motion and require a customer-provided URL if two or more targets object formally.

Section 8 of 8

Hour-by-hour: the first 24 hours

Hours 1-2

  • Create the Vercel project and push the Next.js skeleton with a landing page and intake form.
  • Register the domain and point it at the deployment.
  • Create the Supabase project and draft the scans and steps tables.

Output: Deployed landing page with a working form posting to Supabase.

Hours 3-5

  • Collect 20 public demo URLs from Storylane, Navattic and Walnut galleries.
  • Write a Playwright script that loads one demo and logs whether the hotspot sequence advances.
  • Run it against five demos and record results in a sheet.

Output: Feasibility sheet with 5 recorded results and a reusable script.

Hours 6-8

  • Add screenshot, selector and text capture per step to the runner.
  • Stand up a Browserless account and move the runner behind its session API.
  • Confirm one demo produces a full multi-step snapshot set.

Output: Runner that outputs complete step snapshots for one real demo.

Hours 9-11

  • Wire Stripe Checkout in test mode to a $99 product and create the scan on payment.
  • Build a minimal HTML report route listing each step and its captured text.
  • Send a test report email through Resend.

Output: End-to-end test-mode flow: pay, scan, report, email.

Hours 12-14

  • Draft the teardown email template and the 60-account target list structure.
  • Add the first 10 target accounts with demo URLs and owner names.
  • Write the day-2 build checklist and stop.

Output: Outreach template plus a 10-account starter list.

Complete report

Full 30-day launch report

Read the full generated report

DemoDrift — 30-Day Launch Report

1. Product opportunity and positioning

Interactive demos are sold as set-and-forget assets. They are not. A B2B SaaS that ships weekly changes navigation, renames buttons, moves the pricing page and relabels dashboard columns; the demo built three months ago keeps replaying the old screen. Hotspots stop lighting up, the tour stalls on a step that no longer exists, and the prospect leaves without telling anyone. Nobody owns the check: marketing owns the demo, product owns the release, and the gap between them is where DemoDrift lives.

The buyer is a marketing operations manager or sales-enablement lead at a 50-250 person B2B SaaS publishing five or more Storylane, Navattic or Walnut demos and shipping UI weekly. The trigger is dated — a release or a campaign launch — so the sale closes without procurement. DemoDrift is not a demo builder. It is regression testing for demos that already exist: submit a public demo URL and the live app URL, receive a report naming the exact broken step with a screenshot diff and a suggested selector or screenshot replacement.

The narrowness is deliberate. JEV scored this concept 57.6/100, band C, confidence 0.69. The strongest sub-score is speed to first revenue at 8.42: the free scan is the pitch, the proposal and the proof at once. The weakest are market demand at 3.17 and operational simplicity at 4.91. Both are attacked the same way — pin the buyer to the release-trigger segment so the pain is dated and budgeted, and keep delivery stateless: one managed browser, one managed database, no human review step inside the paid path.

The generic alternatives are a manual monthly click-through (unowned, unscoped, produces no artifact) and a screen recording (not clickable, not diffable). The wedge is that the output is forwardable. A marketing ops lead can attach a DemoDrift report to a launch checklist and hand it to whoever edits the demo. Every report sent is also a fix ticket, and every fix ticket names the product.

2. Smallest sellable MVP

One page, one form, one report, one checkout. The buyer pastes a public demo URL and the live app URL, pays $99 through Stripe, and receives an emailed HTML report with a stable public link plus a PDF.

The build is five days and covers exactly: URL intake with a job queue row, a Playwright runner that advances the demo's hotspot sequence and captures screenshot, DOM selectors and visible text per step, a diff engine combining pixelmatch with selector-presence and text-similarity checks, severity ranking, the HTML and PDF report, Stripe Checkout, Resend delivery and a bare dashboard listing past scans.

Explicitly not built in the first 30 days: demo authoring, transcript personalization, a Chrome extension, CI/CD integration, automatic fix deployment into the demo platform, team seats or SSO, and any support SLA. Each of those would double build time without changing whether the first $99 gets paid.

3. Technical implementation plan

Next.js on Vercel serves the landing page, intake form and public report routes. Submitting a scan inserts a Supabase row and triggers a background function that opens a Browserless session and drives Playwright through the demo. A second pass visits the live app. The diff worker compares stored snapshots using pixelmatch for image deltas, selector presence for broken hotspots and text similarity for stale copy, then writes severity-ranked issues back to Postgres. One LLM call converts each diff into a plain-language fix suggestion, and an optional second call classifies whether a text change is cosmetic or materially wrong (pricing, plan names, feature labels). pdf-lib renders the export; Resend delivers it.

The single hardest technical risk is iFrame and proprietary-player rendering. Many demo platforms embed tours in a player that a generic runner cannot drive. That is why days 1-2 are entirely feasibility testing across 20 real public demos. If the replay rate is low, the concept narrows to the platforms that do work rather than broadening the runner.

4. Pricing and monetization

Three tiers, all self-serve: a $99 Single Demo Audit, a $249 Release Pack covering three demos before a launch, and a $199 monthly Monthly Watch for owners of five or more demos. The paid entry point is deliberately one-time, because the first purchase happens inside a release window and a subscription decision would push it past the deadline.

The free scan is not a tier; it is the acquisition motion, run manually by the founder and capped to keep costs honest. Every buyer is offered the Release Pack in the delivery email, and every Release Pack buyer is offered Monthly Watch after their second release.

5. First-customer acquisition

The only channel is founder-led public demo teardowns. Build a list of 60 B2B SaaS accounts with public interactive demos, run a real scan on one demo per account, and send the finished report only where a genuine break exists. No cold pitch in the first line — the first line names the broken step number and what changed.

Sources for the list: Storylane, Navattic and Walnut public galleries, 'Book a demo' pages that embed a tour, G2 review pages linking to demos, LinkedIn posts announcing a demo launch, Product Hunt launches, and changelog pages for teams shipping weekly. Follow up once after 48 hours with the screenshot of the diff.

Week-one target: 60 accounts listed, 25 reports delivered, 3 replies, 1 checkout started.

6. 30-day execution roadmap

Days 1-5 — build. Day 1 is feasibility only: 20 demo URLs, 5 replay tests, a platform sheet. Day 2 scaffolds Next.js, Supabase and Stripe test mode. Day 3 gets the Playwright runner capturing complete step snapshots. Day 4 builds the diff engine and severity scoring. Day 5 ships the paid path end to end and takes one real $99 charge, then refunds it.

Days 6-12 — first revenue. Day 6 builds the 60-account list. Day 7 sends the first 10 teardowns. Day 8 handles follow-ups. Day 9 sends 15 more and issues checkout links. Day 10 runs calls and logs objections verbatim. Day 11 hand-verifies 10 flagged issues and raises the threshold until false positives drop. Day 12 is the first-sale target: checkout links to every warm responder with a same-day scan guarantee.

Days 13-21 — prove repeatability. Twelve more teardowns on day 13, a public anonymized teardown post on day 14, the $249 Release Pack upsell on day 15, weekly re-scan scheduling and the $199 Monthly Watch on day 16, three more public drift examples on day 17, 25 more teardowns on day 18, a rewritten checkout page with a public sample report on day 19, and the subscription offer to every past buyer on day 20. Day 21 tabulates the funnel and kills the worst outreach variant.

Days 22-30 — scale and settle. A second sending domain, self-serve limited free scan, agency outreach, 30 more teardowns, a $249 versus $349 price test, warm-backlog closing, an accuracy and refund pass, a final outreach wave, and a full Stripe reconciliation on day 30. Verify every sale covered the delivery cost of its own scan before submitting.

7. Revenue and profit scenarios

All three scenarios are projections from stated assumptions, not verified revenue.

ScenarioCustomersARPUGross revenueRefundsChargebacksPayment feesAd spendOperating costs
Conservative3$99$297$0$0$10$0$25
Base10$140$1,400$0$0$48$0$60
Upside22$165$3,630$99$0$124$150$140

Hackathon profit is gross revenue minus refunds, chargebacks, payment fees and paid marketing. Business profit additionally subtracts operating costs. Payment fees assume Stripe at an effective 3.4%. Operating costs cover Vercel, Supabase, Browserless browser minutes, Resend, the domain and LLM calls — a few cents of browser and inference per scan, which is well below the $99 price and keeps every sale above cost.

The base case of 10 customers is deliberately below the concept's original 60-customer projection. Sixty one-time purchases in 30 days from cold outreach would require a reply and conversion rate no solo founder sustains; 10 is defensible if the teardown hit rate holds at one confirmed break in three scans.

8. Main risks and validation experiments

Replayability. If public demos cannot be driven generically, the product has no engine. Test 20 demos on days 1-2; kill if fewer than 8 are replayable.

False positives. A wrong report destroys the one asset that makes the sale. Require two independent signals before flagging a blocker and hand-verify the first 30 reports; pivot to a manual-plus-tool audit if false positives exceed 30% of flagged blockers.

Willingness to pay. Buyers may treat demo QA as a free chore. Send 25 teardowns with a paid follow-up; if 60 teardowns produce zero checkout starts, re-price to $49 before day 20.

Deliverability. Cap sends per domain, warm a second domain from day 22, and switch to LinkedIn if reply rate falls below 2% across 100 sends.

ToS and privacy. Scan only logged-out public URLs, store no personal data, delete screenshots on request; stop the free-scan motion if two targets object formally.

9. First 24-hour action plan

Hours 1-2. Deploy the Next.js skeleton and intake form, register the domain, create the Supabase project.

Hours 3-5. Collect 20 public demo URLs, write the Playwright replay script, run it on five and record results.

Hours 6-8. Add per-step screenshot, selector and text capture, move the runner behind Browserless, confirm one full snapshot set.

Hours 9-11. Wire Stripe Checkout in test mode, build the minimal HTML report route, send a test email through Resend.

Hours 12-14. Draft the teardown template, add the first 10 target accounts, write the day-2 checklist and stop.

Projections only. No customers, revenue, partnerships or sources are claimed anywhere in this report.

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 →