Skip to content
Features

Everything you need to validate, plan and ship your SaaS

Plan My SaaS checks your idea against the live market, then turns it into one complete, consistent blueprint — architecture, feature specs, data models, screens, build phases and the prompts to build it with an AI coding tool.

  • 30section validation report
  • 20document types from your plan
  • 8export bundles
  • 4core modules in every plan

Step 1 · Idea Validation

Know if it is worth building — before any code

Write your idea in one box and answer a few follow-up questions. Plan My SaaS reads it back to you first, so a misreading is caught before research runs, then researches the market and writes a sourced report with a real verdict.

Three reports, one standard

  • Quick Check5 sections — Problem Validation, TAM / SAM / SOM, Competitive Landscape, Legal & Regulatory, Verdict.
  • Full Validation Report30 sections in 5 phases, from the problem to the verdict.
  • Upgrade Analysis5 sections for a product that is already live: Product Snapshot, Positioning Today, Tech Debt & Maintenance Risk, v2 Opportunity Matrix, Upgrade Verdict.
  • A real verdict: build now, build with a pivot, reconsider, or do not build.
  • Sources on every claim — or a clear label when a number is founder-supplied, industry knowledge or a bottom-up calculation.
  • External checks: domain availability, USPTO trademarks, social handles, Hacker News and Reddit demand, Wayback history.
  • An honest roast of the weak parts, and experiments to run before you write code.
  1. 1

    Problem & customer

    5 sections
    • Problem Validation
    • Customer personas
    • Jobs to be done
    • Founder–market fit
    • Customer interview plan
  2. 2

    Market

    4 sections
    • TAM / SAM / SOM
    • Why now
    • Demand signals
    • Analogies & post-mortems
  3. 3

    Competition

    3 sections
    • Competitive Landscape
    • Switching costs
    • Brand & naming check
  4. 4

    Economics

    4 sections
    • Willingness to pay
    • Unit economics
    • Distribution channels
    • Content & SEO landscape
  5. 5

    Risk, legal & verdict

    14 sections
    • Legal & Regulatory
    • Verdict
    • Honest roast
    • Executive summary
    • Founder-side legal
    • Tech-stack lock-in risk
    • Talent & hiring feasibility
    • Risk register
    • Validation experiments
    • SWOT analysis
    • Porter's 5 Forces
    • Business model canvas
    • Product-market fit score
    • Research synthesis
Streams section by sectionKeeps running if you close the tabEmails you when it is readyPause, resume, re-run a sectionChat with the reportPlan Completeness & Idea Strength scoresShare link and PDFPublish to the public directory
How validation works

Step 2 · The Project blueprint

One decided plan, from research to build prompts

Build a validated idea into a project and every finding — personas, market size, competitors, willingness to pay, risks — travels into every stage. Each stage reads the ones before it, so the specs match the architecture and the prompts match the specs.

Research & Analysis

Who you are up against, and where the opening is — before you decide what to build.

  • Competitors with strength, position, tier, funding signals and traffic
  • Problem clusters gathered from real communities, and the market gaps
  • Product-market fit scoring, personas and SWOT
  • Market sizing, a risk matrix and a go-to-market outline

Product Definition

The complete product, split into a first release and the releases after it — each with its reason.

  • Vision, mission and value proposition
  • Modules split into the MVP and later, numbered releases
  • Customer and staff roles, each with its own permission list
  • Pricing tiers with real names and prices, used everywhere after

Architecture

Every part of the system, what it does and how data moves between them.

  • Each component's type, technology, layer and responsibilities
  • Data flows and security boundaries
  • Workers and queues, cache strategy and integrations
  • As a diagram, a list and an editable canvas

Feature Specs

Two to four deep specs for every module — the MVP and every later release.

  • Workflows of seven or more steps, inputs with validation, outputs
  • Business rules, states, edge cases and error handling
  • Permissions, notifications, analytics events and privacy notes
  • A performance budget and acceptance criteria

Technical Design

The data and the API, built on the architecture's stack and the plan's roles.

  • Data models with fields, relations, indexes and notes
  • Services, background jobs, API groups and endpoints with role gates
  • Rate limits, debounce and throttle rules for every product
  • Built on the stack the architecture chose

Build Plan & Releases

Phases that schedule every feature: the MVP first, then each later release.

  • Goal, milestones, deliverables and definition of done for each phase
  • Risks with mitigation, quality gates and a demo moment
  • Go-live criteria and a post-launch plan
  • A versioned release plan, and initiatives → epics → stories

Frontend Blueprint

Every screen your product needs, specified for the people who build it.

  • A route map with role gates, and a separate staff area
  • 20 screen specs with loading, empty, error and partial states
  • A design system decided from your product, contrast-checked
  • Apple apps in Liquid Glass; optional screen images per device

Prompt Studio

Ordered build prompts for Cursor, Claude Code and Lovable.

  • Each prompt has a scope guard and the file it targets
  • Suggested models and the output to expect
  • Built from the real specs, data models, endpoints and phases
  • In build order, so each prompt starts where the last one stopped

Also in every project

Workflow maps (event storming)Decision log (ADRs)Initiatives, epics and storiesRelease planRisk registerProject brief

Documents & exports

20 documents, written from your real plan

Each document gets tables and charts built from the plan's own data — feature tables, priority charts, phase timelines, competitor tables — and follows the same decided plan as everything else.

Product & engineering

  • Product Requirements Document
  • Technical Specification
  • Architecture Documentation
  • arc42 Architecture Document
  • API Reference
  • Feature Documentation Pack
  • Developer Handoff Guide
  • Developer Implementation Notes
  • User Onboarding Guide

Business

  • Business Plan
  • Pitch Deck Content
  • Competitive Analysis Report
  • Investor Summary
  • Go-to-Market Plan
  • Pricing Strategy
  • Revenue Model
  • Risk Register
  • Stakeholder Report
  • Product Roadmap Document
  • User Research Brief
  • Export Center: 8 bundles — Full Blueprint, Idea & Concept, Architecture, Feature Specs, Technical Design, Implementation Phases, AI Prompt Studio, Documentation.
  • Markdown, PDF and JSON — files you own, ready for any editor or coding tool.
  • White-label: “Prepared by” your company, for client work.
  • Share link: a read-only public view of the sections you choose.

Built into every plan

What every real product needs, planned from day one

Whatever you build, every plan includes these four modules in the MVP — guaranteed in code and checked at every stage — and the same engineering rules.

Access & permissions

  • A permission matrix: each role's allowed actions per resource
  • Checked on the server for every request — hiding a button is not access control
  • Tenant isolation, and audited role changes

Staff console

  • Staff accounts in their own realm, with mandatory MFA
  • Owner and support roles; support cannot refund
  • Impersonation needs a reason and expires on its own

Activity & audit trail

  • An append-only event for every meaningful action
  • Sign-in history and active sessions, with remote sign-out
  • Retention, consent, and per-user export and erasure

Customer 360

  • One staff page per user: plan, billing, usage, timeline
  • Suspend, refund, reset MFA, change plan — each audited
  • Search that reaches any user in two steps

Engineering baseline

Rate limits on the server, debounce for typing and autosave, throttle for scroll and telemetry. Written once and added as they are — no AI tokens, identical in every plan.

EndpointsDefault limit
Sign-in, sign-up, password reset, OTP / magic-link verify5 per 15 minutes
Public, signed-out forms and tools5–10 per hour
AI generation and other expensive jobs10 per minute, plus a daily budget
Authenticated writes (create, update, delete)60 per minute
Reads, lists and search120 per minute

How it stays consistent

Why the plan holds up when you hand it over

Most AI planning tools answer one prompt at a time. Plan My SaaS runs a pipeline in which each stage reads the decisions of the ones before it.

One decided plan

Scope, roles, plans and names are decided once and followed by every stage, so the specs, data model, pricing page and docs never disagree.

Always the complete app

Every feature you asked for is planned in full. The MVP is the first release; everything else is scheduled into later releases, each with its reason.

Checked before it is saved

Consistency checks run before anything is stored, and every major stage gets a critique-and-refine pass.

Knows what is out of date

Change a stage and everything built on it is flagged. Generate All shows what will run, why and what it costs, then rebuilds only what is needed.

Third-party rules, quoted

For every service your app uses — Stripe, Razorpay, Google sign-in, Twilio, Shopify and more — the official docs are read and each obligation is quoted with its source.

Your market, not ours

Validation and the plan follow where you sell: the market, the currency and the rules that apply there.

Working with the plan

A plan you keep improving, not a file you download once

Versions

Every stage keeps its history. Lock a version and compare any two.

Branches

Fork a run with different context — B2B or B2C, with or without payments — and compare side by side.

Recovery

An auto-saved snapshot of everything, and a repair prompt that protects the architecture.

Founder checklist

Idea-to-launch steps that tick themselves as the plan is built.

Activity tracker

What has been generated, what is running, and the full history.

Backlog

Feedback, bugs, improvements and change requests in one place.

Nova assistant

Chat about the project. Nova's proposed changes wait for you on a Pending changes page.

Upgrade Mode

Connect an app you already run and plan v2 against the real stack: keep, modify, add or retire each part.

After the plan · Sabha

An AI organisation that builds and runs it

Tell one CEO what you want. It turns the instruction into tickets for six departments — Engineering, Product, Operations, Growth, Sales, and Finance & Legal — and brings you only the decisions that are yours.

  • Engineering works on branches in your own GitHub; code reaches live only when you release it.
  • Spending money, posting publicly and anything that cannot be undone waits for your yes in the Inbox.
  • Every agent reads your blueprint and validation before it works.
  • Your code and hosting stay in your own accounts. Departments switch on as your setup allows — Engineering starts once GitHub is connected.

Start with your idea

Validate it, plan it, then build it.

Describe your idea in a few lines. You get a sourced verdict first, then a blueprint your developers — or your AI coding tool — can build from.