How our prototyping process works

The four validation domains

Every prototype idea gets examined through these four lenses:

1. Business and Project Context – What problem are you solving? Who is it for? What does success look like?
2. Design, Brand, and Content – How should it look and feel? What content needs to exist? What’s the user experience?
3. Functional Requirements and User Flow – What can users do? What happens when they click, submit, or interact?
4. Technical Aspects and Architecture – What technology makes sense? What integrations are needed? What are the constraints?

The output

At the end of this phase, you have a detailed product specification. Everyone agrees on what we’re building, why we’re building it, and how it should work. No assumptions. No surprises mid-build.

This phase has its own deep dive: See Spec-Driven Development in detail

Our AI workflow

We’ve built a custom AI setup using multiple specialized tools. AI handles:

• Code generation for standard patterns and boilerplate
• Component scaffolding to quickly create interface elements
• Pattern implementation for common features like forms, lists, and navigation

But AI doesn’t run the show. Every piece of AI generated code goes through senior developer review. We check for quality, security, and whether it actually solves the problem correctly.

The simplicity principle

Here’s what sets our approach apart: we always choose the simplest path.

AI tools love to over-engineer. Ask an AI to build a score tracker and it’ll suggest React, a database, user authentication, and cloud hosting. Sometimes that’s right. Often it’s overkill.

Our senior developers override AI suggestions when simpler solutions work better. We’re not trying to build impressive technology. We’re trying to validate your idea as fast and cheaply as possible.

Real example: The golf app

A client needed a golf score tracking app. Here’s how the AI-first approach would have gone wrong:

The Problem: Client wanted to track golf scores across rounds. Simple concept, straightforward need.

What AI suggested:

• React frontend framework
• PostgreSQL database
• User authentication system
• Cloud hosting with AWS
• Estimated build time: 30-40 hours

What we built instead:

• Plain HTML with Alpine.js for interactivity
• Browser localStorage for data persistence
• No backend, no database, no server
• Estimated build time: 8 hours

Why this was better: The client didn’t need accounts or cloud storage. They needed to track scores on their phone. LocalStorage works perfectly for that use case. If they lose their phone, they lose their data, but that’s an acceptable trade-off for a prototype.

The result:

• 8 hours instead of 30-40 hours (75% time savings)
• €800 instead of €4,000 in development cost
• Client validated the idea in days, not weeks
• When they decided to move to production, we added the database and accounts

This is why human oversight matters. The AI’s solution was technically correct. Our solution was right for the situation.

What AI does vs. what we control

Here’s the split of responsibilities:

AI handles:

• Code generation for defined patterns
• Creating boilerplate and scaffolding
• Implementing standard features
• Suggesting solutions to common problems

We control:

• Architectural decisions (what technology to use)
• Technology choices (simple vs. complex)
• Scope (what features actually need to exist)
• Quality (is this code maintainable?)
• Business alignment (does this solve the real problem?)

Why this matters for you

Traditional development takes weeks because developers write every line by hand. Fully automated AI development produces bloated, over-engineered solutions.

Our hybrid approach gives you speed without sacrificing judgment. You get a working prototype faster, and you get one that actually fits your needs.

Testing your prototype

The whole point of prototyping is validation. You built something. Now you find out if it works.

This phase puts your prototype in front of real users. You’ll see how they interact with it, where they get confused, what they love, and what they ignore.

Testing options

We offer two approaches depending on your preference and the complexity of what you’re testing:

Guided testing sessions

We run structured testing sessions with users while you observe.

How it works:

• We recruit or you provide test users
• We create a testing script based on key workflows
• We run sessions (usually 30-60 minutes each)
• You watch via screen share or in person
• We document observations and user feedback

Best for:

• Complex workflows that need explanation
• Products where user confusion is likely
• Situations where you want objective facilitation
• When you want professional UX insights

Independent testing

You test directly, we provide support.

How it works:

• We give you the prototype and testing guidelines
• You run sessions with your own users or customers
• You report back with observations
• We help interpret findings and suggest changes

Best for:

• Simple products with obvious workflows
• When you have direct access to target users
• Budget conscious projects
• When you want hands on involvement

Questions validation answers

Good testing answers specific questions about your product:

User adoption:

• Will users actually adopt this workflow?
• Is the core concept intuitive or do they struggle?
• Do they understand what this product does?

Functionality:

• What’s missing that users expect?
• What’s unnecessary that users ignore?
• Where do users get stuck or confused?

Viability:

• Does this solve the problem it’s meant to solve?
• Are users excited or just polite?
• Would they use this instead of their current solution?

The three decision paths

After validation, you’ll choose one of three paths:

Path 1: Kill it

The idea doesn’t validate.

Testing revealed that users don’t want this, don’t understand it, or won’t use it. That’s valuable information.

What this costs:

• Prototype investment: €1,000-€10,000
• What you saved: €30,000-€100,000 in production development

You learned early that this path won’t work. That’s not failure. That’s smart business. Redirect those resources to something more viable.

Path 2: Pivot it

The core works, but needs adjustment.

Users liked parts of it. The concept makes sense but the execution needs changes. Maybe the workflow is wrong. Maybe features are missing. Maybe you’re targeting the wrong audience.

What happens next:

• We analyze what worked and what didn’t
• We adjust the specification based on findings
• We prototype again with changes
• Usually costs 30-50% of the original prototype

Most projects go through at least one pivot. This is normal. Each iteration gets you closer to something users actually want.

Path 3: Build it

Move to production.

Users love it. The workflow makes sense. You’ve validated the core concept and you’re confident this will work.

What happens next:

• We review the prototype for production requirements
• We add security, scalability, and polish
• We build the production version
• Typically costs about 2x the prototype cost

If you spent €5,000 on a prototype, expect around €10,000 to turn it into production software. The prototype code doesn’t get thrown away. It gets enhanced.

Ready for production? We offer Mobile App Development, Web App Development, and Website Development.

How decisions get made

This isn’t a unilateral call. Decision happens through collaborative discussion between you and our team.

We’ll walk through the testing results together. We’ll share our observations and recommendations. You’ll share your business context and constraints. Together, we figure out what makes sense.

If the answer isn’t obvious, that’s fine. Sometimes you need more testing. Sometimes you need to sleep on it. We’re not pushing you toward any particular decision.

There are other ways to build a prototype. Here’s how our approach compares:

vs. traditional agencies

Traditional approach:

• Spend months building an “MVP” that’s still expensive
• Heavy process with extensive documentation
• Large teams with high overhead costs
• Build first, validate later
• Typical cost: €50,000-€150,000 for “minimum” product

Our approach:

• Weeks, not months
• Specification focused on what matters
• Small team, low overhead
• Validate before committing to full build
• Typical cost: €1,000-€10,000 for prototype

vs. freelancers

Freelancer approach:

• Fast code, often skip validation
• Build what you ask for (even if it’s wrong)
• No process for surfacing hidden requirements
• Quality varies widely
• Risk: build the wrong thing quickly

Our approach:

• Fast code with senior oversight
• Challenge assumptions through specification
• Structured process catches gaps early
• Consistent quality through review
• Outcome: build the right thing quickly

vs. no-code/low-code tools

No-code approach:

• Quick to start, limited flexibility
• Can’t surface validation points across domains
• Works for simple projects
• Hits walls with custom functionality
• You’re the architect (without architecture experience)

Our approach:

• Quick to start, unlimited flexibility
• Spec-Driven process examines every angle
• Works for any complexity level
• Custom functionality is our strength
• Professional architecture from the start

The real difference

Every approach has trade-offs. Ours optimizes for one thing: validation speed with quality.

We combine structured specification (so you build the right thing) with AI-assisted development (so you build it fast) with professional oversight (so you build it well).

The result is a working prototype you can test with real users, built in days or weeks instead of months, at a fraction of traditional development cost.

Related:

See spec-driven development in detail
Back to prototyping services