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

Breakage Bill

Breakage Bill reads every saved question in a Metabase instance, matches them against a proposed column rename/drop, and produces a shareable report of exactly which dashboards and alerts break and who to warn.

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

Decide in 20 seconds

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

Speculative6.41/10
MVP build (solo)
5 days
Launch price
$99
Sales to $1,000 revenue
11 customers
First paying customer
Replying with a free, actually-computed Breakage Bill inside recent Metabase forum threads and metabase/metabase GitHub issues where someone describes a column rename or drop breaking dashboards.
Who pays

The analytics engineer or data lead (often the only one) at a 20-300 person company running self-hosted Metabase on Postgres, BigQuery or Redshift, triggered the moment the application team ships a migration that renames, drops or retypes a column.

Biggest execution risk

Monetization potential 4.5/10

Tie the price to a measurable money or time outcome and add a recurring or repeat-purchase path instead of a single low-value charge.

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.6/10.

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

Your first 24 hours

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

0/12
Entry price
$99
Solo build
5 days
30d base revenue
$1,944
30d hackathon profit
$1,767
Section 1 of 8

Product opportunity and positioning

Target customer

The analytics engineer or data lead (often the only one) at a 20-300 person company running self-hosted Metabase on Postgres, BigQuery or Redshift, triggered the moment the application team ships a migration that renames, drops or retypes a column.

Why now

Metabase's runtime-native SQL endpoint plus a dialect-aware parser make static impact analysis of saved questions cheap enough for one person to run as a $99 artifact with no warehouse credentials required.

Problem

BI SQL lives outside version control, so when a column is renamed or dropped nobody knows which of the 200+ saved Metabase questions, dashboards and scheduled alerts depend on it until an executive opens a blank chart.

Solution

Connect Metabase with an API key, paste the migration SQL, and receive a hosted Breakage Bill: affected dashboards, the exact card and column reference, a copy-paste fix snippet, and the list of subscribers to warn, exportable as PDF for the change-approval thread.

Differentiation · Metabase's own search matches the literal token you typed; it cannot see CTE aliases, cannot read GUI-built MBQL questions, and does not know who is subscribed. Breakage Bill delivers the finished, shareable artifact instead of a search result.

1. Product opportunity and positioning

Metabase saves questions as SQL that lives nowhere near version control. When the application team ships ALTER TABLE orders RENAME COLUMN status TO order_status, the failure is not visible anywhere until an executive opens a dashboard and sees a blank chart. Metabase's search box finds the literal word you typed; it does not understand CTE aliases, it cannot read GUI-built MBQL questions whose SQL is compiled at runtime, and it has no idea who is subscribed to the dashboard that will break. Finding the damage by hand means opening questions one at a time and still missing the ones with no visible SQL.

The buyer is narrow and identifiable: the analytics engineer or data lead, often the only one, at a 20-300 person company running self-hosted Metabase on Postgres, BigQuery or Redshift. The trigger is a scheduled event, not a slow-burn irritation - a migration is about to land and someone needs to know what it breaks before it does. The pain is self-diagnosed, publicly posted, and solved by one artifact.

JEV scored this exact concept at 64.1/100 (band C, confidence 0.63). The profile is honest about what it is: speed to first revenue (8.6) and reachable customers (8.36) are the strengths, because the buyer is in a public forum thread describing the break and can buy without a security review or procurement cycle. Monetization (4.52) is the weak point - a single $99 report is a one-off charge with no retention. This plan does not hide that; it adds a repeat-purchase path (Migration Watch at $149/month) and treats the one-time report as the wedge that opens the account, not the business.

Positioning is deliberately narrow. Breakage Bill is not a catalog, not a lineage graph, not a data-quality monitor. It is one connector, one input (a DDL string), one output (a report someone can paste into a change-approval thread). Grai's original promise - column-level lineage used to predict what breaks when upstream data changes - is kept. What is removed is everything that made it heavy: no central metadata server, no Git or CI requirement, no multi-connector setup, no all-in adoption.

Section 2 of 8

Smallest sellable MVP

A one-page flow: paste DDL, enter Metabase host and API key, get a hosted Breakage Bill with a free single-table preview and a Stripe-gated full report.

Must-have features

  • Metabase connect via host URL + API key with a clear validation error path
  • Enumeration of saved questions, dashboards, and dashboard subscriptions/alerts with recipient lists
  • Native SQL extraction for GUI-built MBQL cards through the dataset/native endpoint, without executing queries against the warehouse
  • DDL parser emitting a normalized change set (table, column, op, old/new name) for RENAME, DROP and TYPE changes
  • sqlglot-based reference resolver with case-insensitive and quoted-identifier matching for Postgres, BigQuery and Redshift, plus a SELECT * risk flag
  • One LLM fallback pass for CTE aliasing and dynamic SQL, with a confidence label on every finding
  • Report page grouped by dashboard, with copy-paste fix snippet and subscriber list; public share link and PDF export
  • Stripe Checkout gating the full report behind a free single-table preview

Explicitly out of scope

  • No warehouse credentials or direct database connections
  • No GitHub App, CI integration, dbt manifest parsing or PR commenting
  • No Looker, Tableau or Power BI connectors
  • No automatic rewriting or applying of Metabase questions
  • No full-warehouse lineage graph, data-quality monitoring or catalog
  • No team seats, SSO or enterprise admin

Demo flow (what the buyer sees)

  1. Founder pastes a migration containing a column rename and a drop
  2. Enters a demo Metabase host URL and API key
  3. System enumerates 200+ cards, dashboards and subscriptions
  4. System compiles MBQL cards to native SQL and resolves every column reference
  5. Preview shows findings for one table only, with a blurred count of the rest
  6. Buyer pays $99 through Stripe Checkout
  7. Full Breakage Bill unlocks: dashboards, cards, line references, fix snippets, subscribers
  8. Buyer copies the share link or downloads the PDF into the approval thread
Build plan

Technical implementation plan

Stack

Next.js on VercelNeon Postgres for encrypted connection records, card snapshots and reportsMetabase REST API (api/session, api/card, api/dashboard, dataset/native)Python sqlglot on a small serverless function for dialect-aware parsingOne LLM API for the fuzzy aliasing fallback passStripe CheckoutResend for report delivery emailpdf rendering service for report export

Architecture

A Next.js app handles the connect form and report pages. On submit, a server action validates the Metabase API key, opens a session, and walks the card and dashboard endpoints, compiling MBQL cards to native SQL via dataset/native so no warehouse query runs. The compiled SQL and subscription recipients are stored as an encrypted snapshot row in Neon. A Python function takes the snapshot plus the parsed DDL and runs sqlglot to resolve every column reference, flagging SELECT * and passing unresolved cases through one LLM call that must return a confidence label. Findings are written back as JSON keyed to the report row; the report page renders them grouped by dashboard behind a Stripe entitlement check, and the same JSON renders to PDF.

Build steps

  1. Scaffold Next.js on Vercel and provision Neon Postgres with a connections table, snapshots table and reports table
  2. Implement Metabase session auth and connection validation with explicit error codes
  3. Enumerate databases, collections, cards and dashboards; persist card metadata
  4. Compile MBQL cards through dataset/native and store the resulting SQL string per card
  5. Capture dashboard subscriptions and alert recipients into the snapshot
  6. Build the DDL parser producing a normalized change set and unit-test it against synthetic migrations
  7. Build the sqlglot resolver with per-dialect normalization and identifier folding
  8. Emit findings JSON with card id, dashboard id, line number, snippet and confidence
  9. Add the single LLM fallback pass with a token cap and a certainty floor below which findings are labelled possible
  10. Build the report page, share token and PDF export
  11. Add Stripe Checkout entitlement gating and the free single-table preview
  12. Send delivery email via Resend on successful payment

AI components

  • One LLM pass over unresolved column references to catch CTE aliasing and dynamically constructed SQL, returning a match plus a confidence label; it never overrides a deterministic match
Hardest technical risk: MBQL-to-native SQL compilation is not supported for every question type (models and metrics especially), so a real customer instance can silently under-report coverage unless the report explicitly lists what could not be analyzed.
Section 3 of 8

Pricing and monetization

Single Breakage Bill

Entry offer
$99 one-time

For Analytics engineer or data lead shipping one migration and needing the report for the change-approval thread

  • One Metabase workspace connected
  • Unlimited saved questions and dashboards scanned for one migration
  • Hosted share link plus PDF export
  • Fix snippets and recipient list per broken dashboard
  • Refund if a known affected card is missed

Migration Watch

$149 / month

For Small data team shipping schema changes weekly and wanting a re-run before every release

  • Up to 4 migrations per month
  • Nightly re-scan of saved questions
  • Email/Slack alert when a new question starts referencing a changed column
  • Report history for audit

Model: One-time $99 per-migration report as the wedge, with a $149/month subscription for teams shipping schema changes weekly.

First revenue offer: A free Breakage Bill on the DDL and question SQL already pasted in a public thread, followed by: the full report covering every dashboard, the subscribers to warn, and a no-questions refund if it misses a card you know about.

Expected ACV: $99

Upsell path: Every one-time buyer gets the Migration Watch offer at day 22 with a one-click upgrade link in the report footer; the pitch is a re-run before every release rather than a re-purchase per incident.

Target customers
45
Revenue model
$4,455
Costs
$180
Profit model
$4,275
Section 4 of 8

First-customer acquisition

Primary channel

Replying with a free, actually-computed Breakage Bill inside recent Metabase forum threads and metabase/metabase GitHub issues where someone describes a column rename or drop breaking dashboards.

Where to find them

  • discourse.metabase.com threads from the last 60 days containing 'rename column', 'dropped column' or 'dashboard broke'
  • metabase/metabase GitHub issues with the same phrasing and a named author
  • r/Metabase questions about broken cards after schema changes
  • dbt Slack #tools and #help channels where Metabase users ask about downstream breaks
  • Analytics-engineering blog comment sections and Metabase community Slack threads
  • Inbound self-serve from the free single-DDL preview page

Exact outreach motions

  • Shortlist 20 threads with a named author, the DDL they pasted, and the question SQL they pasted; log all four fields in a sheet
  • For the best 5, compute the Breakage Bill manually from their public DDL and reply with the actual findings - card names, line references, and the GUI-built questions that show no SQL
  • Follow up once after 72 hours with the single dashboard most likely to break, then move on; never post twice in the same thread
  • Offer a shared-screen or ephemeral-key run so a cautious buyer never has to hand over an account-wide key
  • Post the free single-DDL preview in r/Metabase and dbt Slack so inbound can self-serve while outbound continues
  • Ask every buyer which migration they have queued next, then offer the $149 monthly tier against that queue

Message template

Your thread says the migration renames orders.status. I ran the DDL against the question SQL you pasted: 6 saved questions reference it, and 2 of them are GUI-built so they show no SQL in the editor. One is on the Revenue by Week dashboard that has 4 email subscribers. Full report with every affected card, the fix snippet and the subscriber list is $99, refunded if it misses a card you already know about. Want me to run it?
Week-one goal: 5 free Breakage Bills posted publicly and 15 open conversations, with the first $99 payment taken by day 12.
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

Deploy the skeleton and payment plumbing

  • Create the Next.js repo, deploy to Vercel, provision Neon Postgres.
  • Wire Stripe test keys and a $99 checkout route.
  • Ship a landing page with the one-liner and a /health endpoint.
  • Start a local demo Metabase instance in Docker as test data.

Deliverable: Live URL, empty schema, working test checkout.

Day 2Metabase connect

Auth and enumeration

  • Build session auth from host URL plus API key with explicit error codes.
  • Enumerate databases, collections and card counts.
  • Encrypt the connection record with a per-connection key.
  • Ship a connect screen showing 'connected, N cards found'.

Deliverable: Working connect flow against the demo instance.

Day 3Metadata snapshot

Cards, dashboards, subscribers

  • Pull every card via /api/card and dashboard via /api/dashboard.
  • Compile MBQL cards through dataset/native to get real SQL.
  • Capture subscriptions and alert recipients per dashboard.
  • Persist one snapshot row per scan in Neon.

Deliverable: Snapshot JSON covering cards, dashboards and subscribers.

Day 4Matching engine

DDL parse and reference resolution

  • Parse pasted DDL into a table/column/op change set with sqlglot.
  • Resolve references per dialect with quoted and case-insensitive matching.
  • Flag SELECT * on affected tables.
  • Emit findings with card id, line, snippet and confidence.

Deliverable: CLI that turns demo DDL plus snapshot into findings.

Day 5Report artifactMVP shipped

Sellable MVP

  • Build the report page grouped by dashboard with fix snippets.
  • Gate the full report behind Stripe; free tier shows one table only.
  • Add a share link with an unguessable token.
  • Run end to end on demo data and record a 90-second demo.

Deliverable: Sellable MVP plus demo video.

Day 6Pipeline

Build the outreach sheet

  • Shortlist 20 forum and GitHub threads from the last 60 days with named authors.
  • Log thread, author, pasted DDL and pasted question SQL.
  • Draft the free-bill reply template.

Deliverable: 20-row outreach sheet.

Day 7First free bills

Public proof, no pitch

  • Produce 5 manual Breakage Bills from public DDL.
  • Reply in each thread with the actual findings list.
  • Post the free preview to r/Metabase.

Deliverable: 5 public replies sent.

Week 2 · Launch & first sale · 7 days
Day 8Money path

Real payments and delivery

  • Switch Stripe to live mode and publish the refund policy.
  • Send the report link by email via Resend on payment.
  • Add receipt and PDF stub.

Deliverable: Live payments with automated delivery.

Day 9PDF export

Artifact portability

  • Render the report to PDF with dashboard grouping intact.
  • Add copy-paste fix snippets per dialect.
  • Test against three synthetic migrations.

Deliverable: PDF export shipped.

Day 10LLM fallback

Coverage honesty

  • Add one LLM pass for CTE aliases and dynamic SQL.
  • Label every finding certain, likely or possible.
  • Cap spend per scan and log token cost.

Deliverable: Confidence-labeled findings live.

Day 11Outbound round two

Volume and follow-up

  • Reply in 10 more threads with manual bills.
  • Send 72-hour follow-ups to day-7 replies.
  • Update reply-to-close in the sheet.

Deliverable: 15 open conversations.

Day 12First saleFirst sale target

Close on a shared screen

  • Offer the $99 report on a screen share or ephemeral key.
  • Take payment through the live Stripe link.
  • Deliver the report within two hours of payment.

Deliverable: First verified payment.

Day 13Trust path

Remove the API-key objection

  • Ship ephemeral-key instructions and a screen-share booking link.
  • Add a no-key path using pasted card SQL only.
  • Write the one-page security note.

Deliverable: Two low-trust onboarding paths.

Day 14Fix misses

Resolver accuracy

  • Reproduce the top three reference misses from prospects.
  • Patch the resolver and add regression fixtures.
  • Deploy the new build.

Deliverable: Resolver v2 with fixtures.

Week 3 · Repeat & systematize · 7 days
Day 15Channel widening

Inbound surfaces

  • Post the free single-DDL preview in dbt Slack #tools.
  • Publish a page targeting 'metabase rename column dashboard broke'.
  • Log inbound source per signup.

Deliverable: Two inbound surfaces live.

Day 16Recurring offer

Migration Watch tier

  • Build the $149/month Stripe subscription checkout.
  • Add a nightly re-scan cron job.
  • Write the alert email for new references to a changed column.

Deliverable: Subscription tier purchasable.

Day 17Outbound round three

Pipeline depth

  • Reply in 10 more threads.
  • Follow up every open conversation once.
  • Ask each buyer which migration is queued next.

Deliverable: 30 threads touched in total.

Day 18Report quality

Artifact completeness

  • Add the per-dashboard recipient list to the PDF header.
  • Group findings by owning collection.
  • Add a 'what we did not cover' section listing MBQL gaps.

Deliverable: Report v2 shipped.

Day 19Proof assets

Reduce trust friction

  • Record a two-minute walkthrough on synthetic data.
  • Publish an anonymized example report page.
  • Add an FAQ answering the API-key objection.

Deliverable: Public example page and FAQ.

Day 20Conversion

Attack the top objection

  • Review every conversation and name the single most common objection.
  • Rewrite the offer line against that objection.
  • Add a 24-hour turnaround promise.

Deliverable: Revised offer copy.

Day 21Close push

Convert the warm list

  • Message every warm prospect once.
  • Bundle one free re-run into the $99 report.
  • Reconcile payments and refunds to date.

Deliverable: Week-3 revenue tally.

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

Turn buyers into subscribers

  • Email every single-report buyer with the Migration Watch offer.
  • Add a one-click upgrade link in the report footer.
  • Track upgrade rate.

Deliverable: Upsell sequence live.

Day 23Outbound round four

Alert-heavy threads

  • Reply in 10 more threads.
  • Prioritize threads that mention Subscriptions or alerts specifically.
  • Follow up day-17 conversations.

Deliverable: 45 threads touched in total.

Day 24Reliability

Large instances

  • Add timeouts and retries on Metabase API calls.
  • Paginate cards and cap scan time.
  • Add error reporting.

Deliverable: Scan hardening deployed.

Day 25Paid channel test

One measured experiment

  • Run a single $50 sponsored placement in a data newsletter.
  • Measure clicks and signups per dollar.
  • Kill the channel if cost per signup exceeds $25.

Deliverable: Paid channel verdict.

Day 26Long-form content

Search surface

  • Publish a written walkthrough of a real column-rename break on synthetic data.
  • Cross-link from the free preview tool.
  • Submit to one data-engineering newsletter.

Deliverable: One long-form page published.

Day 27Closing

Unpaid quotes

  • Follow up every unpaid quote.
  • State the refund guarantee explicitly in the closing message.
  • Log final pipeline.

Deliverable: Last-call outreach sent.

Day 28Retention check

Verify the recurring loop

  • Run the first nightly re-scan for subscribers.
  • Confirm the alert email fires on a synthetic change.
  • Fix delivery failures.

Deliverable: Recurring loop verified.

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

Reconcile

  • Reconcile Stripe payouts, refunds and fees.
  • Compute hackathon profit and business profit separately.
  • Export all invoices.

Deliverable: Reconciled profit sheet.

Day 30Wrap

Submit and learn

  • Submit final numbers and profit figures.
  • Write a one-page post-mortem with the next 30-day bet.
  • Ship one last fix from user feedback.

Deliverable: Submission plus post-mortem.

Section 6 of 8

Revenue and profit scenarios

How the numbers are defined

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

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

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

Stated assumptions

  • All three scenarios are projections built from stated assumptions, not verified revenue or traction.
  • Conservative: 5 buyers at a blended $105 average across one-time and monthly tiers.
  • Base: 18 buyers at a blended $108 average; assumes roughly 20 qualified threads contacted per week at a modest close rate.
  • Upside: 40 buyers at a blended $112 average; assumes the forum and GitHub thread supply holds and inbound from the free preview converts.
  • Payment processing is modelled at 4% of gross revenue on Stripe (2.9% + $0.30 blended toward 4% on mixed $99 and $149 charges).
  • Refunds are modelled only where a mix of one-time reports creates real refund exposure; the stated refund guarantee is honoured.
  • Chargebacks are modelled at zero because no card disputes are assumed in a 30-day window.
  • Paid marketing spend is zero in Conservative and Base because the channel is organic outreach; Upside includes a single $150 sponsored-placement experiment.
  • Operating costs cover Vercel, Neon, Resend, PDF rendering and LLM/API calls to serve those customers; they are excluded from hackathon profit by rule but included in business profit.

Conservative

5 customers
$525
collected revenue · avg payment $105
Refunds
$0
Chargebacks
$0
Payment fees
$21
Paid marketing
$0
Hackathon profit
$504
Operating costs
$30
Business profit
$474

Base case

18 customers
$1,944
collected revenue · avg payment $108
Refunds
$99
Chargebacks
$0
Payment fees
$78
Paid marketing
$0
Hackathon profit
$1,767
Operating costs
$70
Business profit
$1,697

Optimistic

40 customers
$4,480
collected revenue · avg payment $112
Refunds
$198
Chargebacks
$0
Payment fees
$179
Paid marketing
$150
Hackathon profit
$3,953
Operating costs
$140
Business profit
$3,813

Model your own numbers

Runs in your browser · nothing is saved
Collected revenue
$1,782
Payment fees (3.9%)
$70
Paid marketing
$0
Hackathon profit
$1,713
Business profit
$1,643

Hypothetical arithmetic, not a forecast. The fee rate is a flat 3.9% assumption, refunds and chargebacks are left at zero here, and none of this is tracked data.

Scenario models derived from stated assumptions. These are projections, not verified revenue, customers or traction; actual results may be zero.

Section 7 of 8

Main risks and validation experiments

Risk 1A cautious buyer refuses to hand over an account-wide Metabase API key.

Mitigation

Ship ephemeral-key instructions, a screen-share run, and a pasted-card-SQL path that needs no key at all.

Validation experiment

Ask the next 5 prospects which of the three paths they would accept before any payment is requested.

Kill criteria

If fewer than 2 of 5 accept any path, the connect model is wrong and the product must move to a pasted-SQL-only artifact.

Risk 2Static analysis misses dynamic SQL or heavy aliasing, and one missed break in a paid report triggers a refund or chargeback.

Mitigation

Label every finding certain, likely or possible; publish a 'what we did not cover' section; honour the refund guarantee without argument.

Validation experiment

Run the resolver against 10 synthetic migrations with known ground truth and record recall per dialect.

Kill criteria

If recall on synthetic ground truth stays below 70% after the LLM pass, the paid full-coverage promise has to be rewritten or dropped.

Risk 3The supply of recent, genuinely relevant forum and GitHub threads is smaller than assumed, starving outbound.

Mitigation

Widen to r/Metabase, dbt Slack, Metabase community Slack and the free preview page as parallel surfaces.

Validation experiment

Count qualifying threads from the last 60 days on day 6 and record the number in the sheet.

Kill criteria

If fewer than 15 qualifying threads exist in a 60-day window, outbound cannot fill 30 days and the plan must shift to search-plus-content inbound before day 15.

Risk 4Buyers decide Metabase's built-in search plus manual checking is good enough once they find two of five broken cards themselves.

Mitigation

Lead the free reply with the GUI-built cards that show no SQL, since those are precisely the ones manual checking cannot find.

Validation experiment

In the first 5 free replies, count how many findings the thread author had already found manually and report the gap.

Kill criteria

If manual checking finds more than 80% of reported cards across 5 threads, urgency is weak and the wedge needs a different trigger.

Risk 5MBQL-to-native compilation is unsupported for some question types, capping real coverage and creating a visible gap on a customer's instance.

Mitigation

Detect unsupported card types up front and disclose the exact count in the report header rather than silently omitting them.

Validation experiment

Enumerate card types on the demo instance and measure what percentage compiles to usable SQL.

Kill criteria

If fewer than 60% of cards compile on a realistic instance, the report cannot claim instance-wide coverage and the offer must be scoped per collection.

Section 8 of 8

Hour-by-hour: the first 24 hours

Hours 1-2

  • Create the Next.js repo, deploy to Vercel, provision Neon Postgres.
  • Set up the Stripe account in test mode and note the live-mode requirements.

Output: Live URL and an empty schema.

Hours 3-5

  • Run Metabase in Docker locally and seed a demo instance with cards, dashboards and a subscription.
  • Write down the exact API calls needed for session, card, dashboard and dataset/native.

Output: Demo instance plus a call list for the connect flow.

Hours 6-9

  • Build session auth and card enumeration against the demo instance.
  • Print the first 20 card names and their compiled SQL to the console.

Output: Working enumeration proof.

Hours 10-12

  • Shortlist 10 forum and GitHub threads with pasted DDL and a named author.
  • Draft the reply template and the free-bill script.

Output: 10-row outreach sheet ready to work tomorrow.

Hours 13-16

  • Run the DDL parser against one real pasted migration from the sheet.
  • Hand-resolve the matches for that thread's pasted question SQL.

Output: First manual Breakage Bill, ready to post after the report page exists.

Hours 17-20

  • Build the report page skeleton with dashboard grouping behind a Stripe test gate.
  • Record the first 60-second screen capture of the flow.

Output: Draft report page and demo capture.

Complete report

Full 30-day launch report

Read the full generated report

Breakage Bill - 30-Day Launch Plan

Every revenue and profit figure below is a projection derived from stated assumptions. There are no customers, no revenue, no partnerships and no traction yet.

1. Product opportunity and positioning

Metabase stores its saved questions as SQL that lives nowhere near version control. When the application team ships ALTER TABLE orders RENAME COLUMN status TO order_status, the break is invisible until an executive opens a dashboard and finds a blank chart. Metabase's search box matches the literal token you typed. It does not understand CTE aliases, it cannot read GUI-built MBQL questions whose SQL is compiled at runtime, and it does not know who is subscribed to the dashboard that will break. Manual checking means opening questions one at a time and still missing the ones with no visible SQL.

The buyer is the analytics engineer or data lead, often the only one, at a 20-300 person company running self-hosted Metabase on Postgres, BigQuery or Redshift. The trigger is a scheduled event: a migration is about to land. The pain is self-diagnosed and publicly posted, which is why it can be sold without a brand, a security review or procurement.

JEV scored this concept 64.1/100 (band C, confidence 0.63). Speed to first revenue (8.6) and reachable customers (8.36) are the strengths. Monetization (4.52) is the weak point: a single $99 report is a one-off charge with no retention. This plan answers that directly by treating the one-time report as the account opener and Migration Watch at $149/month as the actual business.

The positioning stays narrow on purpose: one connector, one input, one artifact. Grai's original promise - column-level lineage used to predict what breaks when data changes - is kept. Everything that made the original heavy is removed: no metadata server to maintain, no Git or CI requirement, no multi-connector setup.

2. Smallest sellable MVP

One page. Paste a DDL string, enter the Metabase host URL and an API key, get a hosted Breakage Bill. The free tier shows findings for a single table; Stripe unlocks the full report grouped by dashboard, with the exact card, line reference, copy-paste fix snippet and the list of email and Slack subscribers to warn. PDF export exists because the artifact is going into a change-approval thread, not a dashboard.

The MVP deliberately excludes warehouse credentials, GitHub integration, dbt manifests and every BI tool that is not Metabase. Those are not deferred features; they are different products with different buyers.

3. Technical implementation plan

Next.js on Vercel, Neon Postgres, Metabase REST API, a Python sqlglot function, one LLM API, Stripe, Resend. The connect flow validates the key, enumerates cards and dashboards, and compiles MBQL cards through dataset/native so no query ever runs against the customer's warehouse. That compiled SQL plus subscription recipients becomes an encrypted snapshot. The Python function resolves every column reference against the parsed DDL, flags SELECT *, and passes only unresolved cases to the LLM, which must return a confidence label.

The single hardest risk is coverage: MBQL-to-native compilation is unsupported for some question types, so the report must disclose what it could not analyze rather than quietly omitting it. Every unsupported card count appears in the report header.

4. Pricing and monetization

$99 one-time for a Single Breakage Bill: one workspace, unlimited questions scanned for one migration, share link, PDF, fix snippets, subscriber list. $149/month for Migration Watch: four migrations a month, nightly re-scan, alert when a new question starts referencing a changed column, and report history.

The one-time price sits under the no-approval threshold and needs no security review, because no warehouse credentials change hands. The refund guarantee - refund if the report misses a card the buyer already knew about - converts the risk into a reason to try. Day 22 turns one-time buyers into subscribers by asking about the next migration they already have queued.

5. First-customer acquisition

One channel: replies with a free, actually-computed Breakage Bill inside recent Metabase forum threads and metabase/metabase GitHub issues where someone describes this exact break. Shortlist 20 threads with a named author and their pasted DDL. For the best five, compute the bill from their public SQL and reply with the findings themselves - the two GUI-built questions they could not find by hand are the whole pitch. Never pitch before the findings. Follow up once at 72 hours, then move on; never post twice in a thread.

In parallel, post the free single-DDL preview to r/Metabase and dbt Slack so inbound can self-serve while outbound runs.

6. Thirty-day execution

Days 1-5 build: deploy, connect flow, snapshot, resolver, report page with the Stripe gate. Day 5 is the MVP deadline. Days 6-14 sell: 20-thread sheet, five free public bills, live Stripe, PDF, confidence labelling, a shared-screen path for cautious buyers, and the first paid report by day 12. Days 15-21 widen: dbt Slack, one search-targeted page, the $149 subscription with a nightly re-scan, a public anonymized example and an FAQ. Days 22-30 convert and close: upsell every buyer, one $50 paid-placement test, reliability hardening on large instances, reconcile Stripe, and compute hackathon profit and business profit separately on day 29.

7. Revenue and profit scenarios

Conservative: 5 buyers at $105 blended average, $525 gross, $21 fees, $30 operating cost. Base: 18 buyers at $108, $1,944 gross, $99 refunds, $78 fees, $70 operating. Upside: 40 buyers at $112, $4,480 gross, $198 refunds, $179 fees, $150 paid spend, $140 operating. Processing is modelled at 4% on Stripe. Hackathon profit excludes operating costs by rule; business profit includes them. All three are projections, not verified revenue.

8. Risks and validation

The five real risks: buyers refusing to share an account-wide API key; false negatives in static analysis causing refunds; thin thread supply starving outbound; buyers deciding built-in search is good enough; MBQL compilation gaps. Each has a cheap test this week and a kill criterion - for example, if fewer than 15 qualifying threads exist in a 60-day window, shift to inbound before day 15; if recall on synthetic ground truth stays under 70%, rewrite the coverage promise.

9. First 24 hours

Deploy, seed a demo Metabase, prove enumeration, shortlist 10 threads, hand-produce one real Breakage Bill, and stand up the report page skeleton behind a Stripe test gate. By hour 24 the founder should have one real artifact ready to post and the payment path proven in test mode.

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 →