SaaS Inspector

Evidence-backed idea validation for micro-SaaS founders.
Submit an idea. Get market signals. Receive a Go / Experiment / No-Go verdict — in seconds.

Quick Start · Architecture · Features · API · Scoring · Roadmap

The Problem

Most SaaS founders spend months building products nobody wants. Market research is either too expensive (consultants), too slow (manual), or too shallow (gut feeling).

SaaS Inspector replaces guesswork with a structured, signal-driven validation pipeline that aggregates real-world data points into a single actionable verdict.

Quick Start

Prerequisites

Tool	Version
Node.js	>= 18
Docker & Docker Compose	latest
npm	>= 9

1. Clone & Install

git clone https://github.com/sizwinz/SaaS-Inspector.git
cd SaaS-Inspector
npm install

2. Start Infrastructure

npm run docker:up

This spins up PostgreSQL 16 and Redis 7 via Docker Compose.

3. Configure Environment

cp .env.example .env

Default values work out of the box with the Docker containers.

4. Push Database Schema

npm run db:push
npm run db:generate

Or use the one-liner:

npm run db:setup

5. Launch

npm run dev

Open http://localhost:3000 and validate your first idea.

Features

Intake Form

A structured 10-field form capturing everything the scoring engine needs:

Field	Purpose
Title & One-liner	Identity
Problem Description	Problem clarity
Target User	Audience definition
Channels	Distribution strategy (SEO, Paid, Community, etc.)
Revenue Model	Monetization approach
Keywords	Market signal queries
Competitors	Competitive landscape inputs
Tech Complexity	Feasibility estimation
Unfair Advantage	Defensibility
Notes	Freeform context

Signal Scanners

10 independent scanners aggregate market data into a normalized signal array:

Scanner	Signal Type	Data Source (Production)
Search Volume	`SEARCH_VOLUME`	Google Ads API / SerpAPI
CPC Analysis	`CPC`	Google Ads API
SERP Analysis	`SERP_ANALYSIS`	SerpAPI
GitHub Activity	`GITHUB_ACTIVITY`	GitHub REST API
Product Hunt	`PRODUCT_HUNT`	Product Hunt API
Reddit Buzz	`REDDIT`	Reddit API
Hacker News	`HACKER_NEWS`	Algolia HN API
Job Postings	`JOB_POSTINGS`	Indeed / LinkedIn API
Competitor Ads	`COMPETITOR_ADS`	SpyFu / SimilarWeb
Regulatory Risk	`REGULATORY`	Manual / NLP pipeline

All scanners ship with mock data shaped to match real API responses. Swap to live APIs by replacing the TODO blocks — no interface changes needed.

Weighted Scoring Engine

Four composite scores computed from signal aggregation:

Demand Score — weighted sum of search volume, CPC, community buzz, GitHub activity, SERP competition, job postings
Feasibility Score — derived from tech complexity selection + open-source availability signals
Risk Score — competition density, ad spend signals, regulatory flags, complexity overhead
Confidence — meta-score based on signal diversity and cross-signal corroboration

Verdict System

Three-tier outcome with rationale:

Verdict	Condition
GO	High demand + manageable risk + sufficient confidence
EXPERIMENT	Mixed signals — run validation experiments first
NO-GO	Low demand or high risk with high confidence

Additional Outputs

Contradiction Detection — identifies conflicting signals (e.g., high search volume but zero GitHub activity)
Key Insights — human-readable takeaways from the signal analysis
MVP Scope Generator — must / should / could feature lists with dev hour estimates
Experiment Templates — actionable validation experiments (landing page smoke test, pre-order validation, concierge MVP) with KPI thresholds and cost estimates
Competitor Analysis — feature overlap, pricing tiers, risk assessment per competitor

Architecture

┌──────────────────────────────────────────────────────────┐
│                     FRONTEND (Next.js 16)                │
│                                                          │
│   Landing ──► Intake Form ──► Report View (tabbed)       │
│                                  ├── Scores & Verdict    │
│                                  ├── Signal Breakdown    │
│                                  ├── Competitor Map      │
│                                  ├── MVP Scope           │
│                                  └── Experiments         │
├──────────────────────────────────────────────────────────┤
│                      API LAYER                           │
│                                                          │
│   POST /api/validate ──► Full pipeline (inline)          │
│   GET  /api/scans/:id ──► Scan status + data             │
│   GET  /api/reports/:id ──► Complete report               │
├──────────────────────────────────────────────────────────┤
│                    BUSINESS LOGIC                         │
│                                                          │
│   Scanners ──► Signal[] ──► Scoring Engine ──► Verdict   │
│                              ├── MVP Scope Generator     │
│                              ├── Experiment Templates    │
│                              └── Competitor Analyzer     │
├──────────────────────────────────────────────────────────┤
│                    DATA LAYER                             │
│                                                          │
│   Prisma 7 (Driver Adapter) ──► PostgreSQL 16            │
│   BullMQ ──► Redis 7 (queue-ready)                       │
└──────────────────────────────────────────────────────────┘

Project Structure

src/
├── app/
│   ├── api/
│   │   ├── validate/route.ts        # POST — full scan pipeline
│   │   ├── scans/[id]/route.ts      # GET  — scan status
│   │   └── reports/[id]/route.ts    # GET  — full report
│   ├── dashboard/page.tsx           # Scan history
│   ├── report/[id]/page.tsx         # Tabbed report view
│   ├── validate/page.tsx            # Intake form
│   ├── layout.tsx                   # Root layout + nav
│   └── page.tsx                     # Landing page
├── components/
│   ├── intake-form.tsx              # 10-field structured form
│   ├── score-card.tsx               # Score display + grid
│   ├── verdict-banner.tsx           # Go / Experiment / No-Go
│   ├── signals-list.tsx             # Signal breakdown
│   ├── competitor-map.tsx           # Competitor table
│   ├── experiment-cards.tsx         # Experiment templates
│   └── mvp-scope.tsx               # Must/should/could lists
├── lib/
│   ├── db.ts                        # Prisma client (PrismaPg adapter)
│   ├── utils.ts                     # cn(), formatScore, colors
│   ├── scoring/
│   │   ├── index.ts                 # Weighted scoring engine
│   │   └── mvp.ts                   # MVP scope generator
│   ├── scanners/
│   │   ├── index.ts                 # 10 signal scanners
│   │   └── competitors.ts           # Competitor analysis
│   ├── experiments/
│   │   └── templates.ts             # Experiment templates
│   └── queue/
│       └── index.ts                 # BullMQ queue setup
├── types/
│   └── index.ts                     # Zod schemas + TS interfaces
└── generated/prisma/                # Auto-generated Prisma client

Tech Stack

Layer	Technology	Why
Framework	Next.js 16 (App Router + Turbopack)	Server components, API routes, fast DX
Language	TypeScript 5	End-to-end type safety
Database	PostgreSQL 16	Relational data with JSON columns
ORM	Prisma 7 (with `@prisma/adapter-pg`)	Type-safe queries, schema-as-code
Validation	Zod 4	Runtime schema validation
Styling	Tailwind CSS 4	Utility-first, rapid prototyping
UI Primitives	Radix UI	Accessible, unstyled components
Icons	Lucide React	Clean, consistent iconography
Queue	BullMQ + Redis 7	Async job processing (production-ready)
Containerization	Docker Compose	One-command infra setup

API Reference

`POST /api/validate`

Submit an idea for full validation.

Request Body:

{
  "title": "AI Resume Builder",
  "oneLiner": "GPT-powered resumes that land interviews",
  "targetUser": "Job seekers aged 22-35",
  "channels": ["SEO", "ProductHunt", "LinkedIn"],
  "revenueModel": "subscription",
  "keywords": ["ai resume", "resume builder", "ats resume"],
  "competitors": ["resume.io", "zety.com"],
  "techComplexity": "medium",
  "problemDesc": "Writing resumes is tedious and most are rejected by ATS",
  "unfairAdvantage": "Fine-tuned model on 10k successful resumes",
  "notes": "Focus on tech industry first"
}

Response:

{
  "scanId": "uuid",
  "ideaId": "uuid",
  "status": "COMPLETED",
  "scores": {
    "demand": 72,
    "feasibility": 65,
    "risk": 45,
    "confidence": 58
  },
  "verdict": "EXPERIMENT",
  "verdictRationale": "Moderate demand with manageable competition...",
  "contradictions": ["High search volume but low GitHub activity..."],
  "keyInsights": ["Strong CPC signals indicate commercial intent..."],
  "mvpScope": { "must": [...], "should": [...], "could": [...] },
  "experiments": [...],
  "competitors": [...]
}

`GET /api/scans/:id`

Retrieve scan status and results.

`GET /api/reports/:id`

Retrieve full report (accepts scan ID or idea ID).

Scoring Algorithm

The scoring engine uses weighted signal aggregation with configurable weights:

Demand Score = Σ(signal_score × weight) / Σ(weights)

Weights:
  Search Volume    0.25
  CPC              0.15
  GitHub Activity  0.15
  Community Buzz   0.20
  SERP Competition 0.15
  Job Postings     0.10

Each signal is normalized to a 0–100 scale before aggregation. The confidence score reflects how many signal types were successfully collected and whether signals corroborate each other.

Verdict Logic

composite = (demand × 0.4) + (feasibility × 0.3) + ((100 - risk) × 0.3)

if composite >= 65 AND confidence >= 50  →  GO
if composite <= 35 AND confidence >= 40  →  NO_GO
otherwise                                →  EXPERIMENT

Database Schema

5 models with full relational integrity:

User (1) ──► (N) Idea (1) ──► (N) Scan (1) ──► (N) Signal
                                         └──► (N) Experiment

Model	Key Fields
User	email, name
Idea	title, oneLiner, targetUser, channels (JSON), keywords (JSON), competitors (JSON), techComplexity
Scan	status (enum), demandScore, feasibilityScore, riskScore, confidence, verdict (enum), mvpScope (JSON)
Signal	type (14-variant enum), source, rawData (JSON), score
Experiment	type (6-variant enum), status (enum), setupSteps (JSON), estimatedCost, kpiThresholds (JSON)

Available Scripts

Command	Description
`npm run dev`	Start dev server (Turbopack)
`npm run build`	Production build (generates Prisma client + Next.js)
`npm run start`	Start production server
`npm run lint`	Run ESLint
`npm run db:setup`	Docker up + schema push + client generate
`npm run db:push`	Push Prisma schema to database
`npm run db:migrate`	Run Prisma migrations
`npm run db:studio`	Open Prisma Studio GUI
`npm run db:generate`	Regenerate Prisma client
`npm run docker:up`	Start Docker containers
`npm run docker:down`	Stop Docker containers

Roadmap

Phase 1 — Foundation (Current)

Phase 2 — Live Data

Connect real APIs (SerpAPI, GitHub, Reddit, HN)
Background job processing via BullMQ workers
Rate limiting and API key management
Webhook notifications on scan completion

Phase 3 — Intelligence

LLM-powered insight generation
Historical trend analysis
Scan comparison and diff views
PDF report export

Phase 4 — Platform

Contributing

Fork the repository
Create a feature branch (git checkout -b feat/amazing-feature)
Commit your changes (git commit -m 'feat: add amazing feature')
Push to the branch (git push origin feat/amazing-feature)
Open a Pull Request

License

This project is licensed under the MIT License.

_{Built for founders who validate before they build.}

Name		Name	Last commit message	Last commit date
Latest commit History 4 Commits
.claude		.claude
prisma		prisma
public		public
src		src
.gitignore		.gitignore
README.md		README.md
docker-compose.yml		docker-compose.yml
eslint.config.mjs		eslint.config.mjs
next.config.ts		next.config.ts
package-lock.json		package-lock.json
package.json		package.json
postcss.config.mjs		postcss.config.mjs
prisma.config.ts		prisma.config.ts
tsconfig.json		tsconfig.json

Navigation Menu

Repository files navigation

SaaS Inspector

The Problem

Quick Start

Prerequisites

1. Clone & Install

2. Start Infrastructure

3. Configure Environment

4. Push Database Schema

5. Launch

Features

Intake Form

Signal Scanners

Weighted Scoring Engine

Verdict System

Additional Outputs

Architecture

Project Structure

Tech Stack

API Reference

`POST /api/validate`

`GET /api/scans/:id`

`GET /api/reports/:id`

Scoring Algorithm

Verdict Logic

Database Schema

Available Scripts

Roadmap

Phase 1 — Foundation (Current)

Phase 2 — Live Data

Phase 3 — Intelligence

Phase 4 — Platform

Contributing

License

About

Releases

Packages

Contributors

Languages

Folders and files

Latest commit

History

Repository files navigation

SaaS Inspector

The Problem

Quick Start

Prerequisites

1. Clone & Install

2. Start Infrastructure

3. Configure Environment

4. Push Database Schema

5. Launch

Features

Intake Form

Signal Scanners

Weighted Scoring Engine

Verdict System

Additional Outputs

Architecture

Project Structure

Tech Stack

API Reference

POST /api/validate

GET /api/scans/:id

GET /api/reports/:id

Scoring Algorithm

Verdict Logic

Database Schema

Available Scripts

Roadmap

Phase 1 — Foundation (Current)

Phase 2 — Live Data

Phase 3 — Intelligence

Phase 4 — Platform

Contributing

License

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

`POST /api/validate`

`GET /api/scans/:id`

`GET /api/reports/:id`