Design low-fidelity mockups and test your SaaS solution with customers before building. Get feedback on workflows, iterate, and form your advisory board.

Stage 3: Solution Validation - Design, Test, and Refine Before Building

You've proven the problem is real and people will pay for a solution.

Now comes the hard part: designing a solution that's actually better than alternatives customers could use instead.

This is where most bootstrapped SaaS founders stumble. They're so eager to code that they skip thorough solution testing. They build something that looks good to them, launch it, and discover customers wanted something completely different.

Stage 3 prevents that disaster.

Over weeks 5-8 of your 8-week validation sprint, you'll create mockups of your solution, show them to 10-15 customers, gather feedback, and iterate. Only after this feedback loop do you write a single line of production code.

This is what separates successful SaaS founders from failed ones.

Why Mockups Before Code

Building a full product before testing your solution approach is like constructing a house before showing the blueprints to anyone. You might love the result. Your customers might hate it.

Mockups cost $40-100 in software (Figma, Adobe XD). Code costs $5,000-50,000 in time and money. The math is obvious.

But there's a deeper reason to test mockups: customer workflows are more important than features.

Most founders think about what their software does (feature lists). Successful founders think about how customers will use it (workflows).

A customer doesn't care if you have "real-time notifications" and "advanced filtering." They care if they can accomplish their job in 30 minutes instead of 3 hours.

Mockups let you test workflows with customers before committing to code.

Part 1: Create Low-Fidelity Mockups (2-3 weeks)

What to create:

12-15 key screens showing:

Onboarding flow: How does someone get started?
Core workflow: How do they solve their main problem?
Key features: What are the 5-7 essential capabilities?
Dashboard/overview: What does success look like?
Settings/customization: Can they adjust to their needs?

Don't create:

Perfect pixel designs
Polished branding
Detailed copy
All possible features

The goal is clarity on workflow, not beauty.

Tools to Use

Figma (free tier): Professional-grade, widely used, free plan covers everything you need.

Adobe XD (free tier): Good if you know Adobe products. Less intuitive than Figma.

Balsamiq: Quick wireframes, looks hand-drawn, great for demonstrating concepts.

Hand-drawn sketches: Photograph them. Seriously. Some founders use hand-drawn wireframes and they work fine. Don't let perfectionism block progress.

What Each Screen Should Show

Screen 1-3: Onboarding

Sign up flow: Email, password, company name
Setup wizard: What's your [key question]? How many [relevant metric]?
Tutorial: "Here's how you'll use this. Click through these 3 steps."

Key question: Is onboarding clear enough that a new user understands how to get started?

Screen 4-7: Core Workflow (The Job to Be Done)

If your product solves "manual reporting," show:

How to input data (or auto-sync if that's your approach)
How to organize and view data
How to generate reports
How to share with clients

Key question: Can a user accomplish their main job without being confused?

Screen 8-10: Key Features

Show your 5-7 core features in context:

Integration with Shopify/Xero/Stripe (if relevant)
Team collaboration (if multi-user)
Customization options
Automation/rules (if that's valuable)

Key question: Are these features obvious and accessible, or hidden in confusing menus?

Screen 11-12: Dashboard/Overview

What does a returning user see?
What metrics matter most?
What's the call-to-action?

Key question: Does it feel like success, or overwhelming complexity?

Screen 13-15: Mobile/Secondary Flows

Mobile responsiveness (if relevant)
Admin/settings area
Billing/account management

Design Principles

Keep it simple. Use:

1 or 2 typefaces (don't need brand fonts)
2-3 colors (plus black/white). UI kits from Figma Community make this easy.
Standard UI patterns (buttons, forms, modals that people recognize)
Whitespace. Breathing room. Don't cram everything in.

Use real data. Don't show:

"Lorem ipsum" placeholder text
Generic data like "Item 1," "Customer A"

Do show:

Real example scenarios: If your product manages client projects, show actual project names a user would recognize
Real data: Real dollar amounts, dates, names (fictional but realistic)

Time investment: 30-40 hours of design work over 2-3 weeks.

Use Figma templates. Search "SaaS dashboard template" or "[your industry] UI kit." Copy a template, modify it to show your workflow, and you're done in a fraction of the time.

Part 2: Solution Validation Sessions (1-2 weeks)

You've created mockups. Now show them to customers and watch how they react.

The Process

Schedule 10-15 video calls with people from your Stage 1 and Stage 2 validation (people who showed strong interest and signed LOIs).

Time: 30-45 minutes per session

Format:

5 minutes: Context. "You told me you spend 15 hours weekly on reporting. Here's my approach to solving that."
20-30 minutes: Walkthrough. You navigate through screens while talking. Pause and ask questions.
5 minutes: Feedback. "Does this solve your problem?" "What's confusing?"

Critical rule: Record every session (with permission). Review recordings later to spot patterns.

What to Listen For

Green lights (they understand and like your approach):

"This is exactly what we need."

"When can we start using this?"

"This would save us so much time." (Specific time savings indicate they visualized using it.)

"We'd use this for [specific use case]." (Customers imagining real use cases is gold.)

"I don't see anything confusing here."

Yellow flags (they like it but want changes):

"Interesting, but we'd use it differently."

"Can you add [feature request]?"

"This solves the problem, but we'd need [integration]."

Multiple customers requesting the same feature = it's essential.

Red flags (your approach is wrong):

"I'm confused about how this works."

Long pauses when you show key workflows = they don't get it.

"I'd have to check with my team" (indicates low personal urgency—they might not be the decision-maker)

"Interesting, but we'd probably stick with [existing solution]." = your approach doesn't differentiate enough

How to Ask Questions

After walking through, ask:

"On a scale of 1-10, does this solve your problem?" (Target: 7+)
"What part confused you?" (Listen for clarity issues)
"What would need to be different for you to use this instead of [current solution]?" (Their answer reveals your competitive advantage)
"Which features matter most to you?" (Identify your core 5-7 features to build first)
"If we launched this in 6 weeks, would you sign up?" (Gauge commitment)

How to Iterate

After 5 sessions, compile feedback:

What % said 7+ on your "does this solve it" question?
What were common confusions?
What features kept getting requested?

Target success metrics:

✓ 80%+ rate the solution 7+/10

✓ No consistent confusion about core workflow

✓ No more than 2-3 common feature requests (beyond your core 5-7)

If you hit 80%, you're ready to code.

If you're below 60%, iterate:

Update mockups based on feedback (1-2 days)

Show revised versions to next 5 people (1 week)

Repeat until 80% say 7+

Typical pattern: 2-3 iteration cycles over 4-6 weeks.

Part 3: Form Your Customer Advisory Board

While validating solutions, recruit your first advisory board. These 5-10 people will guide your entire development and become your biggest advocates.

Who to Invite

The most enthusiastic people from your validation process:

People who rated your mockups 8-9/10
People who asked "when can we use it?"
People who want to see you succeed

Invitation Email

"Hi [Name],

Your feedback has been incredibly valuable in shaping [Product]. I'd like to invite you to join our Customer Advisory Board.

This means:

Monthly 30-minute video calls to review progress and prioritize features

Early access to new features before anyone else

Lifetime 40% discount ($60/month instead of $100) as a thank you

Direct influence on our roadmap—your votes matter

Interested? Our first call is [date].

Thanks,

[Your name]"

Monthly Meeting Format (30-45 minutes)

Progress update (10 min): What did we build this month?
Feedback session (15 min): What's working? What's not?
Roadmap voting (15 min): Vote on next month's priorities
Open discussion (5 min): Any concerns or ideas?

Why This Works

For you:

Continuous validation loop
Direct feedback from ideal customers
Built-in evangelists
Reduced risk of building wrong features
Natural advocates who refer others

For them:

Shape a tool perfect for their needs
Early competitive advantage
Relationship with founder
Special pricing

Real example: Intercom formed a customer advisory board during early stages. Those customers became their largest accounts, paying $50K+ annually. The feedback loop kept Intercom aligned with market needs while they grew to $1B+ valuation.

Part 4: Real-World Example

Let's follow a bootstrapped B2B SaaS founder validating a project management tool for service agencies.

The Problem: Agencies juggle Asana, Slack, Google Drive, and invoicing tools. They want one place to manage projects, time, and client communication.

Stage 3 mockups created:

Onboarding: 3 screens
Project creation and management: 4 screens
Time tracking integration: 2 screens
Client portal: 2 screens
Dashboard: 2 screens
Mobile view: 2 screens

Time invested: 35 hours over 3 weeks.

Validation sessions (12 conducted):

Session 1-5: 60% rated 7+. Confusion about time tracking workflow.
Feedback: "How does it sync with our billable hours? Do we have to enter time twice?"

Iteration 1: Redesigned time tracking flow. Added clear "auto-sync from Toggl" option.

Session 6-10: 82% rated 7+. Much better. Common request: "Can we white-label this for our clients?"

Iteration 2: Added white-label option to dashboard and roadmap.

Session 11-12: 85% rated 8+. Ready to code.

Advisory board formed: 8 people recruited. First monthly call scheduled.

Result: Before writing code, the founder:

✓ Tested workflow with 12 real customers

✓ Identified critical feature (white-labeling)

✓ Built-in customer feedback loop

✓ Has 8 advocates who will likely buy and refer others

✓ Can confidently move to Stage 4 (business model validation)

Common Mistakes in Stage 3

Mistake 1: Building in private.

Don't create mockups and keep them to yourself while you code for 3 months. Get feedback early and often.

Mistake 2: Taking feedback too literally.

If one person wants a feature, don't add it. If 5+ people want it, it goes on the roadmap.

Mistake 3: Showing only to friendly people.

Your friends will be nice. Test with neutral customers who aren't trying to please you.

Mistake 4: Confusing mockup feedback with real product feedback.

Mockups are good for workflows and overall approach. Once you have a real product, behavior changes. People click things they wouldn't click in mockups.

Mistake 5: Skipping advisory board formation.

Advisory boards aren't optional—they're your customer feedback lifeline during development.

Success Metrics for Stage 3

✓ 80%+ rate your solution 7+/10

✓ No consistent confusion about core workflow

✓ 5-10 people recruited for advisory board

✓ You can identify your 5-7 core features with certainty

✓ You've iterated at least once based on feedback

✓ Customers are asking "when can we use this?"

What Happens Next

After Stage 3, you move to Stage 4: Business Model Validation.

In Stage 4, you'll run a paid pilot with 5-10 customers, validate your churn assumptions, and confirm your unit economics work before scaling.

But first, you need mockups that validate your solution approach.

Ready for Stage 4? Continue with: Stage 4: Business Model Validation - Running Your Paid Pilot

Want a full walkthrough? Read: The Complete 4-Stage SaaS Validation Framework

Curious about building? See: From Zero to 100K ARR: Building Your SaaS Product