claude-code-arcane 1.0.0

package/skills/free-tool-strategy/references/tool-types-guide.md

@@ -0,0 +1,253 @@
+# Tool Types Guide — Comprehensive Reference for Free Marketing Tools
+
+Each tool type explained with examples, build complexity, typical outcomes, and design guidance.
+
+---
+
+## The 7 Tool Types
+
+### 1. Calculators
+
+**What they do:** Take numerical or categorical inputs → output a calculated result (a number, range, or score).
+
+**Examples:**
+- SaaS Pricing Calculator ("What should you charge?")
+- ROI Calculator ("How much would you save?")
+- LTV Calculator ("What's your customer worth?")
+- Churn Impact Calculator ("What does 1% more churn cost you?")
+- Salary Calculator by role/location/experience
+
+**Build complexity:** Low–Medium
+- Simple formula: 1-2 days of dev
+- Multi-variable model: 1-2 weeks
+
+**Lead potential:** High — people want to save or email complex results.
+
+**SEO value:** Medium-High — calculators earn links from resource pages and ranking for "[topic] calculator" queries.
+
+**Viral potential:** Medium — people share results when they're surprising or validating.
+
+**Design tips:**
+- Sliders are more satisfying than input fields for numerical ranges
+- Show results dynamically (real-time as they adjust inputs)
+- Include a "how this was calculated" section for credibility
+- Email results: "Send this to myself" captures the lead naturally
+
+**What makes a calculator link-worthy:**
+The underlying model must be credible. If you're calculating LTV, show your formula and cite your assumptions. A calculator with methodology is shareable content, not just a widget.
+
+---
+
+### 2. Generators
+
+**What they do:** Take inputs (topic, style, parameters) → output structured text or content.
+
+**Examples:**
+- Headline Generator (input: product + audience → 10 headline options)
+- LinkedIn Bio Generator
+- Job Description Generator
+- Email Subject Line Generator
+- Product Description Generator
+- Business Name Generator
+
+**Build complexity:** Low (template-based) to High (LLM-powered)
+
+**Template-based (madlibs):**
+- 1-3 days
+- Take inputs, fill template slots, combine with variations
+- Deterministic output
+
+**LLM-powered:**
+- 1-2 weeks (API integration + prompt engineering)
+- Generative output
+- Requires API key costs to be modeled into business case
+
+**Lead potential:** Medium — output varies, so gating with email is natural if you offer "save and regenerate."
+
+**SEO value:** High for "[topic] generator free" — some of the highest-traffic tools are generators.
+
+**Viral potential:** High — people share clever or surprisingly good generated outputs.
+
+**Design tips:**
+- Show an example output before the user enters anything (reduces bounce)
+- Generate 3-5 variations, not just 1
+- "Copy to clipboard" button is a must
+- "Generate again" encourages engagement (more pageviews, better SEO signal)
+
+---
+
+### 3. Checkers
+
+**What they do:** Analyze a URL, email, text, file, or domain → return an audit or pass/fail assessment.
+
+**Examples:**
+- SEO Checker ("Analyze your page's SEO")
+- Email Spam Checker ("Will your email hit spam?")
+- Website Speed Checker
+- LinkedIn Profile Checker
+- Ad Copy Compliance Checker
+- Password Strength Checker
+- Domain Authority Checker
+
+**Build complexity:** Medium–High
+- Text analysis (readability, keyword density): 2-5 days
+- URL crawling (page analysis): 1-2 weeks
+- Email delivery testing: 1-2 weeks + email infrastructure
+
+**Lead potential:** High — checker results are specific to the user; saves/exports feel natural.
+
+**SEO value:** Very High — "[type] checker" or "check my [thing]" queries are often high-volume.
+
+**Viral potential:** High — "Your page scored 47/100 — here's what's broken" drives sharing.
+
+**Design tips:**
+- Score the output (0-100) — people anchor on scores and compare
+- Categorize results: Critical / Warnings / Passed
+- Prioritize issues — don't just list everything, rank by impact
+- Loading state matters — show progress (feels like analysis is happening)
+
+---
+
+### 4. Graders
+
+**What they do:** Score something holistically against a rubric. More opinionated than a checker — you're grading against a defined standard.
+
+**Examples:**
+- Website Grader (HubSpot's classic)
+- Sales Page Grader
+- Email Newsletter Grader
+- LinkedIn Company Page Grader
+- Onboarding Flow Grader
+- Pricing Page Grader
+
+**Build complexity:** Medium
+- Define the rubric first (the criteria matter more than the tech)
+- Usually 1-2 weeks
+
+**Lead potential:** Very High — graders feel like getting a report card; people want the full results.
+
+**SEO value:** High for niche graders ("sales page grader" etc.).
+
+**Viral potential:** Medium-High — share your score as social proof or to invite critique.
+
+**Design tips:**
+- The grade (A-F or 0-100) is the hook — show it prominently
+- Break down the grade into components (e.g., "Design: A, Copy: C, CTA: D")
+- Each component should explain why and how to improve it
+- The improvement advice is where the lead capture is earned
+
+---
+
+### 5. Converters
+
+**What they do:** Transform input from one format to another. Pure utility.
+
+**Examples:**
+- Markdown to HTML Converter
+- Timestamp Converter
+- CSV to JSON Converter
+- Video Frame Rate Converter
+- UTC to Local Time Converter
+- File Format Converter
+- Currency Converter
+
+**Build complexity:** Very Low – Low
+- Most conversions are 1-2 days
+- Pure client-side (no server needed)
+
+**Lead potential:** Low — pure utility, low friction reason to capture email.
+
+**SEO value:** Medium — "convert X to Y" queries exist but are dominated by large tool sites.
+
+**Viral potential:** Low — people bookmark and return, don't share.
+
+**When to build:** Only if the conversion is specific to your audience (e.g., a SaaS for designers building a "Figma token to CSS converter"). Generic converters are dominated by free sites with years of SEO authority.
+
+---
+
+### 6. Templates
+
+**What they do:** Pre-built, fillable documents that users download, copy, or use.
+
+**Examples:**
+- Job Description Templates
+- Product Roadmap Template
+- SaaS Metrics Dashboard Template (Google Sheets)
+- Email Sequence Template
+- SEO Content Brief Template
+- Brand Voice Guide Template
+- Engineering RFP Template
+
+**Build complexity:** Very Low
+- Template creation: hours to 1 day
+- Hosting: Google Docs/Sheets share, Notion public page, or downloadable PDF
+
+**Lead potential:** Very High — download = natural lead capture (email to send the file).
+
+**SEO value:** High — "[role] template" queries are competitive but high-intent.
+
+**Viral potential:** Medium — people share templates that save them real time.
+
+**Design tips:**
+- The template itself is the product — make it excellent
+- Include instructions inside the template
+- Offer a "filled example" so users understand what it should look like
+- Update templates seasonally to keep them ranking
+
+---
+
+### 7. Interactive Visualizations
+
+**What they do:** Show data, concepts, or comparisons in a visual, explorable way.
+
+**Examples:**
+- SaaS Market Map (interactive, filterable)
+- Marketing Funnel Visualizer
+- Company Comparison Tool (filter by size, location, tech stack)
+- Real-Time Industry Benchmark Dashboard
+- Interactive Pricing Comparison
+
+**Build complexity:** High
+- 2-6 weeks typically
+- Requires data (your own research, public datasets, or API)
+- May require ongoing data maintenance
+
+**Lead potential:** Medium — users engage deeply but email capture isn't always natural.
+
+**SEO value:** Very High if data-driven — journalists and bloggers link to unique datasets.
+
+**Viral potential:** Very High if the data is surprising or highly visual — these are your link magnets.
+
+**Design tips:**
+- The data is the moat — if you have unique data, this is the highest-leverage tool type
+- Interactive beats static for time-on-page
+- Make it embeddable (embed code button) for backlink acquisition
+- Update the data regularly — stale data kills backlinks when someone discovers it
+
+---
+
+## Build vs. No-Code Decision Guide
+
+| Tool Type | No-Code Options | When to Go Custom Dev |
+|-----------|---------------|----------------------|
+| Calculator | Outgrow, Calconic, Typeform | When logic is complex, or brand/speed matters |
+| Generator | Typeform + Zapier, GPT wrappers | When you need custom LLM behavior |
+| Checker | Limited — usually needs dev | Always (URL crawling, text analysis) |
+| Grader | Outgrow, Involve.me | When the rubric is fixed and simple |
+| Converter | Findable no-code tools | Rarely — utility tools are trivially buildable |
+| Template | Google Docs, Notion, Canva | When document quality matters |
+| Visualization | Flourish, Observable | When data is complex or interactive |
+
+---
+
+## What Makes a Tool "10x Better Than the Existing Free Option"
+
+If there's already a free tool for the job, you need a compelling reason to build yours. One of:
+
+1. **Niche specificity** — existing tool is generic, yours is specific to your audience's workflow
+2. **Better UX** — existing tools are ugly, clunky, or require too many steps
+3. **Integrated action** — after results, existing tools drop the user; yours offers next steps or a trial
+4. **Unique data or model** — your checker uses proprietary data that others don't have
+5. **Shareable output** — existing tools give results in a table; yours generates a shareable card or PDF
+
+Don't build "the same tool, but ours." That's a traffic fight you won't win. Build "the tool that does what the others don't."

package/skills/free-tool-strategy/scripts/tool_roi_estimator.py

@@ -0,0 +1,401 @@
+#!/usr/bin/env python3
+"""
+tool_roi_estimator.py — Estimates ROI of building a free marketing tool.
+
+Models the return from a free tool given build cost, maintenance, expected traffic,
+conversion rate, and lead value. Outputs ROI timeline, break-even month, and
+minimum traffic needed to justify the investment.
+
+Usage:
+    python3 tool_roi_estimator.py                    # runs embedded sample
+    python3 tool_roi_estimator.py params.json        # uses your params
+    echo '{"build_cost": 5000, "lead_value": 200}' | python3 tool_roi_estimator.py
+
+JSON input format:
+    {
+        "build_cost": 5000,              # One-time engineering cost ($) — dev time × rate
+        "monthly_maintenance": 150,      # Ongoing server, API, ops cost per month ($)
+        "traffic_month_1": 500,          # Expected organic sessions in month 1
+        "traffic_growth_rate": 0.15,     # Monthly organic traffic growth rate (0.15 = 15%)
+        "tool_completion_rate": 0.55,    # % of visitors who complete the tool (0.55 = 55%)
+        "lead_capture_rate": 0.10,       # % of completions who give email (0.10 = 10%)
+        "lead_to_trial_rate": 0.08,      # % of leads who start a trial
+        "trial_to_paid_rate": 0.25,      # % of trials who become paid customers
+        "ltv": 1200,                     # Customer LTV ($)
+        "months_to_model": 24,           # How many months to project
+        "seo_ramp_months": 3,            # Months before organic traffic kicks in (0 if PH/HN spike)
+        "backlink_value_monthly": 200,   # Estimated value of earned backlinks (DA × niche rate)
+        "tool_name": "ROI Calculator"    # For display only
+    }
+"""
+
+import json
+import math
+import sys
+
+
+# ---------------------------------------------------------------------------
+# Core calculations
+# ---------------------------------------------------------------------------
+
+def traffic_at_month(params, month):
+    """
+    Traffic grows from near-zero during SEO ramp, then compounds.
+    Month 1 = launch spike (Product Hunt / HN etc.) if ramp=0, or baseline.
+    """
+    ramp = params.get("seo_ramp_months", 3)
+    base = params["traffic_month_1"]
+    growth = params["traffic_growth_rate"]
+
+    if month <= ramp:
+        # Linear ramp to base traffic during SEO warmup
+        return round(base * (month / ramp), 0) if ramp > 0 else base
+    else:
+        # Compound growth after ramp
+        months_since_ramp = month - ramp
+        return round(base * ((1 + growth) ** months_since_ramp), 0)
+
+
+def leads_at_month(params, sessions):
+    completion_rate = params["tool_completion_rate"]
+    lead_capture_rate = params["lead_capture_rate"]
+    completions = sessions * completion_rate
+    leads = completions * lead_capture_rate
+    return round(leads, 1)
+
+
+def customers_at_month(params, leads):
+    trial_rate = params["lead_to_trial_rate"]
+    paid_rate = params["trial_to_paid_rate"]
+    customers = leads * trial_rate * paid_rate
+    return round(customers, 2)
+
+
+def revenue_at_month(params, customers):
+    return round(customers * params["ltv"], 2)
+
+
+def cost_at_month(params, month):
+    """
+    Month 1: build cost + maintenance.
+    Subsequent months: maintenance only.
+    """
+    maintenance = params["monthly_maintenance"]
+    backlink_value = params.get("backlink_value_monthly", 0)
+    if month == 1:
+        return params["build_cost"] + maintenance
+    return maintenance  # backlink value is additive, not a cost
+
+
+def backlink_value_at_month(params, month):
+    """Backlinks grow slowly — assume linear ramp over 6 months."""
+    max_val = params.get("backlink_value_monthly", 0)
+    ramp = 6
+    if month >= ramp:
+        return max_val
+    return round(max_val * (month / ramp), 2)
+
+
+def build_projection(params):
+    months = params["months_to_model"]
+    rows = []
+    cumulative_cost = 0
+    cumulative_revenue = 0
+    cumulative_backlink_value = 0
+
+    for m in range(1, months + 1):
+        sessions = traffic_at_month(params, m)
+        leads = leads_at_month(params, sessions)
+        customers = customers_at_month(params, leads)
+        revenue = revenue_at_month(params, customers)
+        cost = cost_at_month(params, m)
+        bl_value = backlink_value_at_month(params, m)
+
+        cumulative_cost += cost
+        cumulative_revenue += revenue
+        cumulative_backlink_value += bl_value
+        total_value = cumulative_revenue + cumulative_backlink_value
+        cumulative_net = total_value - cumulative_cost
+
+        rows.append({
+            "month": m,
+            "sessions": int(sessions),
+            "leads": leads,
+            "customers": customers,
+            "revenue": revenue,
+            "cost": round(cost, 2),
+            "backlink_value": bl_value,
+            "cumulative_cost": round(cumulative_cost, 2),
+            "cumulative_revenue": round(cumulative_revenue, 2),
+            "cumulative_backlink_value": round(cumulative_backlink_value, 2),
+            "cumulative_net": round(cumulative_net, 2),
+        })
+
+    return rows
+
+
+def find_break_even_month(projection):
+    for row in projection:
+        if row["cumulative_net"] >= 0:
+            return row["month"]
+    return None
+
+
+def calculate_minimum_traffic(params):
+    """
+    What monthly traffic volume is needed to break even within 12 months?
+    Solve for traffic where 12-month cumulative net >= 0.
+    Uses binary search.
+    """
+    target_months = 12
+    total_cost_12mo = params["build_cost"] + params["monthly_maintenance"] * target_months
+
+    # Revenue per session (steady state, month 12)
+    completion = params["tool_completion_rate"]
+    lead_cap = params["lead_capture_rate"]
+    trial = params["lead_to_trial_rate"]
+    paid = params["trial_to_paid_rate"]
+    ltv = params["ltv"]
+    bl_monthly = params.get("backlink_value_monthly", 0)
+
+    revenue_per_session = completion * lead_cap * trial * paid * ltv
+
+    # Total sessions needed over 12 months (ignoring ramp for simplification)
+    if revenue_per_session <= 0:
+        return None
+
+    # With backlink value: total_value = sessions_total × revenue_per_session + 12 × bl_monthly
+    # sessions_total = total needed
+    total_bl_value = bl_monthly * 12 * 0.5  # ramp factor
+    needed_from_sessions = max(0, total_cost_12mo - total_bl_value)
+    min_monthly_sessions = needed_from_sessions / (target_months * 0.6 * revenue_per_session)
+    # 0.6 factor: first 3 months lower traffic during ramp
+
+    return round(min_monthly_sessions, 0)
+
+
+def calculate_roi_summary(projection, params):
+    if not projection:
+        return {}
+    last = projection[-1]
+    total_cost = last["cumulative_cost"]
+    total_revenue = last["cumulative_revenue"]
+    total_value = total_revenue + last["cumulative_backlink_value"]
+    net = last["cumulative_net"]
+    roi = (net / total_cost * 100) if total_cost > 0 else 0
+    total_leads = sum(r["leads"] for r in projection)
+    total_customers = sum(r["customers"] for r in projection)
+    cost_per_lead = total_cost / total_leads if total_leads > 0 else 0
+
+    return {
+        "total_cost": round(total_cost, 2),
+        "total_revenue": round(total_revenue, 2),
+        "total_value_with_backlinks": round(total_value, 2),
+        "net_benefit": round(net, 2),
+        "roi_pct": round(roi, 1),
+        "total_leads": round(total_leads, 0),
+        "total_customers": round(total_customers, 1),
+        "cost_per_lead": round(cost_per_lead, 2),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Formatting
+# ---------------------------------------------------------------------------
+
+def fc(value):
+    return f"${value:,.2f}"
+
+
+def fp(value):
+    return f"{value:.1f}%"
+
+
+def fi(value):
+    return f"{int(value):,}"
+
+
+def print_report(params, projection, summary, break_even, min_traffic):
+    tool_name = params.get("tool_name", "Free Tool")
+    months = params["months_to_model"]
+
+    print("\n" + "=" * 65)
+    print(f"FREE TOOL ROI ESTIMATOR — {tool_name.upper()}")
+    print("=" * 65)
+
+    print("\n📊 INPUT PARAMETERS")
+    print(f"  Build cost (one-time):          {fc(params['build_cost'])}")
+    print(f"  Monthly maintenance:            {fc(params['monthly_maintenance'])}")
+    print(f"  Starting monthly traffic:       {fi(params['traffic_month_1'])} sessions")
+    print(f"  Monthly traffic growth:         {fp(params['traffic_growth_rate'] * 100)}")
+    print(f"  SEO ramp period:               {params.get('seo_ramp_months', 3)} months")
+    print(f"  Tool completion rate:           {fp(params['tool_completion_rate'] * 100)}")
+    print(f"  Lead capture rate:             {fp(params['lead_capture_rate'] * 100)} (of completions)")
+    print(f"  Lead → trial rate:             {fp(params['lead_to_trial_rate'] * 100)}")
+    print(f"  Trial → paid rate:             {fp(params['trial_to_paid_rate'] * 100)}")
+    print(f"  LTV:                           {fc(params['ltv'])}")
+    print(f"  Backlink value (monthly):      {fc(params.get('backlink_value_monthly', 0))}")
+
+    print(f"\n📈 {months}-MONTH SUMMARY")
+    print(f"  Total investment:               {fc(summary['total_cost'])}")
+    print(f"  Revenue from leads:             {fc(summary['total_revenue'])}")
+    print(f"  Backlink value:                 {fc(summary.get('total_value_with_backlinks', 0) - summary['total_revenue'])}")
+    print(f"  Total value generated:          {fc(summary.get('total_value_with_backlinks', summary['total_revenue']))}")
+    print(f"  Net benefit:                    {fc(summary['net_benefit'])}")
+    print(f"  ROI:                            {fp(summary['roi_pct'])}")
+
+    print(f"\n🎯 LEAD & CUSTOMER METRICS")
+    print(f"  Total leads generated:          {fi(summary['total_leads'])}")
+    print(f"  Total customers acquired:       {round(summary['total_customers'], 1)}")
+    print(f"  Cost per lead:                  {fc(summary['cost_per_lead'])}")
+    print(f"  CAC via tool:                   {fc(summary['total_cost'] / max(summary['total_customers'], 0.01))}")
+
+    print(f"\n⏱  BREAK-EVEN ANALYSIS")
+    if break_even:
+        print(f"  Break-even month:               Month {break_even}")
+        assessment = "🟢 Fast payback" if break_even <= 6 else "🟡 Moderate" if break_even <= 12 else "🔴 Long payback"
+        print(f"  Assessment:                     {assessment}")
+    else:
+        print(f"  Break-even month:               Not reached in {months} months ⚠️")
+        print(f"  Action needed: Increase traffic, improve completion/capture rate, or reduce build cost")
+
+    if min_traffic:
+        print(f"  Min traffic for 12-mo break-even: {fi(min_traffic)} sessions/month")
+        current = params["traffic_month_1"]
+        if current >= min_traffic:
+            print(f"  Your projected traffic ({fi(current)}/mo) exceeds minimum ✅")
+        else:
+            gap = min_traffic - current
+            print(f"  Traffic gap: need {fi(gap)} more sessions/month than projected ⚠️")
+
+    print(f"\n📅 MONTHLY PROJECTION")
+    print(f"  {'Mo':>3}  {'Sessions':>9}  {'Leads':>6}  {'Custs':>6}  {'Revenue':>9}  {'Cum Net':>10}")
+    print(f"  {'-'*3}  {'-'*9}  {'-'*6}  {'-'*6}  {'-'*9}  {'-'*10}")
+    for row in projection:
+        net = row["cumulative_net"]
+        net_str = fc(net) if net >= 0 else f"({fc(abs(net))})"
+        be_marker = " ← break-even" if row["month"] == break_even else ""
+        print(f"  {row['month']:>3}  {fi(row['sessions']):>9}  {row['leads']:>6.1f}  {row['customers']:>6.2f}"
+              f"  {fc(row['revenue']):>9}  {net_str:>10}{be_marker}")
+
+    print("\n" + "=" * 65)
+
+    # Recommendations
+    print("\n💡 RECOMMENDATIONS")
+    roi = summary["roi_pct"]
+    if roi > 200:
+        print("  ✅ Strong ROI case — build it, invest in distribution")
+    elif roi > 50:
+        print("  🟡 Positive ROI but slim — validate keyword volume before committing full build cost")
+        print("     Consider: MVP version (no-code) to test demand before full dev investment")
+    else:
+        print("  🔴 ROI case is weak — investigate:")
+        print("     1. Is the target keyword validated? (check search volume)")
+        print("     2. Can you reduce build cost? (no-code MVP first)")
+        print("     3. Is the lead-to-customer conversion realistic?")
+        print("     4. Is the LTV accurate?")
+
+    completion = params["tool_completion_rate"]
+    if completion < 0.40:
+        print("  ⚠️  Low completion rate — reconsider UX or number of required inputs")
+    if params["lead_capture_rate"] < 0.05:
+        print("  ⚠️  Low lead capture — check gate placement (should be after value is delivered)")
+    if break_even and break_even > 18:
+        print("  ⚠️  Long break-even — prioritize launch distribution to accelerate traffic ramp")
+
+
+# ---------------------------------------------------------------------------
+# Default sample
+# ---------------------------------------------------------------------------
+
+DEFAULT_PARAMS = {
+    "tool_name": "SaaS ROI Calculator",
+    "build_cost": 4000,
+    "monthly_maintenance": 100,
+    "traffic_month_1": 600,
+    "traffic_growth_rate": 0.12,
+    "seo_ramp_months": 3,
+    "tool_completion_rate": 0.55,
+    "lead_capture_rate": 0.12,
+    "lead_to_trial_rate": 0.08,
+    "trial_to_paid_rate": 0.25,
+    "ltv": 1400,
+    "months_to_model": 18,
+    "backlink_value_monthly": 150,
+}
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Estimates ROI of building a free marketing tool. "
+                    "Models return given build cost, maintenance, traffic, "
+                    "conversion rate, and lead value."
+    )
+    parser.add_argument(
+        "file", nargs="?", default=None,
+        help="Path to a JSON file with tool parameters. "
+             "If omitted, reads from stdin or runs embedded sample."
+    )
+    args = parser.parse_args()
+
+    params = None
+
+    if args.file:
+        try:
+            with open(args.file) as f:
+                params = json.load(f)
+        except Exception as e:
+            print(f"Error reading file: {e}", file=sys.stderr)
+            sys.exit(1)
+    elif not sys.stdin.isatty():
+        raw = sys.stdin.read().strip()
+        if raw:
+            try:
+                params = json.loads(raw)
+            except Exception as e:
+                print(f"Error reading stdin: {e}", file=sys.stderr)
+                sys.exit(1)
+        else:
+            print("No input provided — running with sample parameters.\n")
+            params = DEFAULT_PARAMS
+    else:
+        print("No input provided — running with sample parameters.\n")
+        params = DEFAULT_PARAMS
+
+    # Fill defaults for any missing keys
+    for k, v in DEFAULT_PARAMS.items():
+        params.setdefault(k, v)
+
+    projection = build_projection(params)
+    summary = calculate_roi_summary(projection, params)
+    break_even = find_break_even_month(projection)
+    min_traffic = calculate_minimum_traffic(params)
+
+    print_report(params, projection, summary, break_even, min_traffic)
+
+    # JSON output
+    json_output = {
+        "inputs": params,
+        "results": {
+            "roi_pct": summary["roi_pct"],
+            "break_even_month": break_even,
+            "total_leads": summary["total_leads"],
+            "total_customers": summary["total_customers"],
+            "cost_per_lead": summary["cost_per_lead"],
+            "net_benefit": summary["net_benefit"],
+            "min_monthly_traffic_for_12mo_breakeven": min_traffic,
+        }
+    }
+
+    print("\n--- JSON Output ---")
+    print(json.dumps(json_output, indent=2))
+
+
+if __name__ == "__main__":
+    main()