Business Validation Framework

A repeatable, AI-driven method for validating and launching businesses.

Core Idea

Every new business — whether dropshipping, SaaS, info product, or service — answers the same fundamental question: will people pay for this? This framework answers that question in 4 weeks for ~$2-5k using AI agents to do the work that would take a team of humans months.

The framework is business-model-agnostic. The first four stages are identical regardless of what you’re selling. Only the “fulfillment backend” changes.

The Method

┌─────────────┐     ┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│  1. RESEARCH │ ──→ │  2. PRESENCE  │ ──→ │  3. TRAFFIC   │ ──→ │  4. VALIDATE  │
│  (AI agent)  │     │  (storefront) │     │  (paid ads)   │     │  (metrics)    │
└─────────────┘     └──────────────┘     └──────────────┘     └──────────────┘
                                                                       │
                                                              ┌────────┴────────┐
                                                              │  GO / ITERATE   │
                                                              │    / KILL       │
                                                              └─────────────────┘

Stage 1: Research (Days 1-3)

Input: A business idea or niche keyword. Output: Structured market report with GO/NO-GO recommendation.

The research agent:

1. Market sizing — search volume, TAM estimates, competition density
2. Customer discovery — scrape Reddit, Amazon reviews, forums, Quora for pain points, objections, buying triggers, demographics
3. Competitive landscape — who else is in the space, their pricing, positioning, weaknesses
4. Persona generation — 3-5 buyer personas with demographics, pain points, and messaging angles
5. Positioning recommendation — how to differentiate, what angles to test
6. Unit economics estimate — expected CPA range, margin analysis, break-even scenarios

Tools (existing in Omni): WebSearch (Kagi), WebReader, Http, Browser, LLM reasoning via Agent/Op framework.

New build required: A composable research workflow/skill that chains these tools together with structured LLM prompts. Output is a JSON/markdown report.

Stage 2: Presence (Days 3-7)

Input: Research report. Output: A live web presence (landing page or storefront) optimized for conversion.

The agent generates and deploys:

• Headlines, copy, CTAs derived from research personas
• Product/service description
• Pricing
• Checkout or lead capture mechanism

Presence backends (pluggable):

Key design constraint: The landing page must be generatable by an LLM. This means templated HTML (Lucid, Jinja, or a headless CMS) where the agent fills in copy, images, and pricing from the research report. Not hand-coded per business.

Tools (existing): Lucid HTML (Haskell), Servant web framework, Stripe billing (PIL), Omni/Deploy. New build required: Landing page template system — a set of HTML templates the LLM populates. Shopify API client (for physical products only).

Stage 3: Traffic (Days 7-21)

Input: Landing page URL, research report (for targeting), ad copy variants. Output: Live ad campaigns driving traffic to the presence.

The agent:

1. Generates ad copy — platform-specific formats from research personas
   • Google RSA: 15 headlines (30 chars) × 4 descriptions (90 chars)
   • Meta: primary text + headline + description + image, per persona
2. Creates campaigns — programmatically via platform APIs
3. Sets budgets and bidding — start with maximize-conversions, fixed daily budget
4. Monitors performance — daily pulls of impressions, clicks, CTR, conversions, CPA

Ad copy generation is pure LLM work — structured prompt that takes the research report and outputs correctly-formatted ad variants. This can be a skill/workflow, no API integration needed.

Platform integrations:

Minimum viable: Google Ads alone is sufficient for validation. Meta adds reach. TikTok/Reddit are optional for specific niches.

New build required: Google Ads API client, Meta Ads API client, ad copy generation workflow.

Stage 4: Validate (Days 21-28)

Input: Campaign performance data (14+ days). Output: GO / ITERATE / KILL decision with confidence level.

Core metrics:

• CPA (cost per acquisition) — what does each customer cost?
• CVR (conversion rate) — landing page effectiveness
• ROAS (return on ad spend) — revenue / ad cost (if taking real orders)
• CTR (click-through rate) — ad creative quality signal
• Statistical significance — enough data to trust?

Decision matrix:

New build required: Metrics aggregation script, unit economics calculator, significance test. Can start as a spreadsheet/script, formalize into a dashboard later.

What Exists in Omni Today

Application: StreetSignal

StreetSignal is a SaaS product — hyperlocal crime analysis for Columbus RE investors.

Current state:

• Business model canvas done (~/omni/ava/Biz/StreetSignal.md)
• Landing page built (Haskell/Lucid/Servant, ~/omni/ava/Biz/StreetSignal/Web.hs)
• Sample report generated for German Village
• Stripe checkout link (placeholder)
• Key hypotheses identified (H1-H6), none validated

Applying the framework:

StreetSignal-specific open questions:

• H1 (will they pay $150/mo?) can be directly tested via this framework
• H6 (retention) cannot be tested pre-launch — but initial conversion validates demand
• The $150/mo price point means you only need ~20 subscribers to cover costs

Application: High-Ticket Dropshipping

Current state: No niche selected. Framework for execution outlined (~/ava/ben/business/dropship-agent-plan.md).

Applying the framework:

Implementation Plan

Phase 1: Research Agent (Week 1)

Build the niche research workflow as an Ava skill or Agent Op program.

Tasks:

1. Design the research prompt chain (keyword → searches → scrape → synthesize → report)
2. Build structured output format (JSON schema for market report)
3. Test on 2-3 niches to calibrate quality
4. Test on StreetSignal’s market to validate against known information

Deliverable: research_niche("keyword") → structured market report

Phase 2: Presence Layer (Week 1-2)

Build the landing page template system + Shopify client.

Tasks:

1. Create parameterized HTML landing page template (Lucid or Jinja) — takes: headline, subhead, body copy, CTA text, price, product image URL, testimonials
2. Build Shopify GraphQL API client (for dropship path)
3. Deploy StreetSignal landing page to real domain with real Stripe link
4. Test: research report → landing page generation → live URL

Deliverable: create_presence(research_report, business_type) → live URL

Phase 3: Ad System (Week 2-3)

Build ad copy generation + platform API clients.

Tasks:

1. Ad copy generation prompt (research report → platform-formatted ad variants)
2. Google Ads API: account setup, developer token, Python client, campaign creation
3. Meta Ads API: Business Manager setup, System User token, Python client
4. Campaign launch automation: takes ad variants + budget + targeting → live campaigns
5. Daily metrics pull + storage

Deliverable: launch_campaign(ads, platform, budget) → campaign_id + daily metrics

Phase 4: Validation Engine (Week 3-4)

Build metrics aggregation and decision logic.

Tasks:

1. Metrics aggregation: pull from Google + Meta APIs, normalize
2. Unit economics calculator: CPA vs margin → profitability
3. Statistical significance test: enough conversions to trust the signal?
4. Decision recommendation: GO / ITERATE / KILL with explanation
5. Simple reporting (markdown report or web dashboard)

Deliverable: validate(campaign_ids) → {verdict, metrics, confidence, recommendation}

Budget per Niche Test

Timeline

Open Questions

1. StreetSignal first or dropship first? StreetSignal is further along (landing page exists, sample report exists, domain knowledge is deep). Lower validation cost. Recommend starting here.
2. Repo location: Biz/Validation/ for the framework, Biz/StreetSignal/ and Biz/Dropship/ for business-specific code?
3. How many niches to test in parallel? One at a time keeps focus. Two if you want to hedge.
4. Legal structure: LLC before taking real money. Can validate with “waitlist” / “coming soon” flow to avoid needing LLC for initial ad test.
5. Your friend’s deal flow / angel investing — orthogonal to this. Learn his ad methods, apply them here. The validation framework is the general version of what he does for saunas.

Principles

1. Spend money to learn, not to launch. The $2-5k is tuition, not investment. You’re buying information about whether the business works.
2. Kill fast. If the numbers don’t work after 2 weeks of ads, stop. Don’t optimize a bad idea.
3. Automate the boring parts. Research, copy generation, campaign setup — these are AI tasks. Your time goes to judgment calls: niche selection, positioning decisions, GO/KILL.
4. One framework, many businesses. Every new idea goes through the same 4-stage pipeline. The framework gets better with each iteration.
5. Validate before building. Don’t write code, don’t source products, don’t build features until the ads prove demand exists.