The most expensive bug in software is
building the wrong thing correctly.
The Product Blueprint is product due diligence for a world where writing code got cheap. In a fixed two-week sprint, we pressure-test whether the problem is worth solving, find the reason people would actually come back, and define the smallest version that can succeed before you commit a cent to development.
// IT DOESN'T JUST TELL YOU WHAT TO BUILD. IT TELLS YOU WHETHER YOU SHOULD.
What your brief shows
The User-Facing App
Visible scope
~30%
of the product
What The Brief Misses
Product viability
~70%
of what decides success
What actually decides if it works
Your brief describes features. Not why users will actually care.
Most software projects don't fail because of bad code. They fail because the wrong product got approved: the problem wasn't worth solving, the moment that brings someone back never got found, or the basic operating questions got pushed to "figure out later." Those are the decisions still sitting unmade the day the budget gets signed off.
We're a software engineering team that got tired of watching founders spend real money on the wrong version of their product. We built this process to fix the product, not just the brief, before a single line of code gets written.
The budget pays for features, but the painful problem they solve was never validated.
Vendors look comparable on paper, but are each pricing a completely different underlying product.
Hidden scope, from value hooks to compliance, surfaces as expensive budget surprises mid-build.
The first version launches, but users churn because the retention mechanics were never designed.
Without a Blueprint
- [-]You approve spend against assumptions nobody has named.
- [-]Hidden scope becomes a budget conversation mid-build.
- [-]Architecture decisions get made when delays are already expensive.
- [-]Rebuild risk accumulates invisibly until the product has to operate for real.
- [-]Quotes cannot be compared because each team is pricing a different product.
With a Blueprint
- [+]You know what Phase 1 should include before approving development spend.
- [+]Missing scope is exposed while it is still cheap to change the plan.
- [+]Technical, operational, and compliance risks are visible before they become rework.
- [+]Quotes can be compared against the same build-ready scope document.
- [+]You can proceed, simplify, defer, or walk away with full confidence.
One recent brief missed 160 hours of critical work: the kind that normally surfaces mid-build, as a budget surprise nobody saw coming.
The RFQ described the user-facing app beautifully. But it missed the entire operating layer needed to actually run the business.
In this case, the gap was operational: multi-tenant data partitioning, white-label brand controls, and automated employer reporting. That's the foundational layer that makes a platform safe to deploy across multiple enterprise clients, not just one. In other Blueprints the gap looks completely different. Sometimes it's a third of the planned feature set the product doesn't actually need. Sometimes it's the retention hook the team hadn't found yet. The Blueprint surfaces whatever risk is biggest, not always the same one, and not always the one you expected.
The most valuable part wasn't the missing hours. It was showing the founders what the product needed to be before they spent the capital building the wrong version.
One written, build-ready spec. Here's exactly what's in it, by tier.
This isn't a slide deck or a verbal recommendation. It's a single document you could hand to any developer and say “quote against this.” Every tier adds named, specific sections to that document. Here is what you are actually paying for at each level.
The Decision
// The floor. Nobody walks away without this, even at Simple.
The Go/No-Go Verdict
A direct call on whether this is worth building as scoped, needs reshaping, or isn’t worth the spend yet, from someone who has to live with being wrong about it.
Problem & Hook Check
Whether the problem is painful enough for people to pay or switch for, and where the moment lives that brings them back a second time.
The Real Phase 1
What ships first, and what gets cut, faked, or pushed to later: usually smaller and sharper than the original brief.
A Fixed Build Number
A real price to build Phase 1, checked against how the product actually needs to run, not just how it looks in a deck.
What It Takes To Survive Real Users
// Worth it the moment real users, real money, or real data are involved, which is most commercial builds.
Friction & Retention Plan
Where users get stuck or bounce, and the specific mechanic designed to bring them back without you having to think about it.
Admin, Roles & Data Rules
Who can do what, how data is structured and partitioned, and the back-end workflows nobody puts in a pitch deck but every operator needs on day one.
Running Costs, In Real Numbers
Hosting, scaling, and third-party API costs translated into a monthly figure, not a footnote you discover after launch.
Risk Register & Roadmap
Every compliance, technical, and adoption risk we found, plus what’s deliberately deferred to Phase 2 and why, so later decisions don’t undo earlier ones.
The Screens, Before They Cost You Anything
// Worth it once there are enough screens or flows that guessing at layout would cost more in revisions than designing it upfront.
UI Wireframes
Every core flow laid out screen by screen, so layout and navigation decisions get made before a developer has to guess at them.
High-Fidelity Mockups
The finished look of the key screens, styled and real, so you’re approving a product you can see, not a verbal description of one.
Analytics & Event Plan
Every interaction worth tracking, mapped to the reporting you’ll need to know if the retention plan above is actually working.
Two sessions. Two weeks.
One decision made clearly.
01
Pressure-Test The Brief
Session - 90 minutes
We walk through the project, business constraints, users, data, admin needs, and unknowns, looking for where spend would be approved on weak assumptions.
02
Expose The Hidden Product
Analysis - ~2 weeks
The architect who ran the session maps the real product: viability, value hook, scope, technical direction, operating model, risks, roadmap, and Phase 1 estimate.
03
Decide Before You Spend
Session - 90 minutes
We present the findings, pressure-test the plan together, and finalise the next step: proceed, simplify, defer, or walk away.
Why trust our judgment?
Most product advice comes from people who never have to build what they recommend. We do.
We didn't create the Blueprint because we wanted to be strategy consultants. We created it because, as engineers and architects, we kept seeing the same expensive pattern:
The app looked right. The scope looked reasonable. The quote looked competitive.
But once we got underneath the surface, the real product hadn't been designed yet.
- The retention mechanics weren't clear.
- The operating model was missing.
- The admin workflows didn't exist.
- The compliance requirements were assumed away.
The most expensive mistake in software isn't bad engineering. It's approving development spend before the product itself is understood.
We aren't selling you a generic canvas or a corporate workshop. We are giving you the unvarnished judgment of practitioners who have estimated, architected, built, launched, and maintained commercial software. We've been close enough to enough builds to know exactly where the hidden assumptions live.
The Blueprint exists for one simple reason: fixing a product on paper is dramatically cheaper than fixing it in production.
Choose the level of pressure-testing your build needs.
Most commercial builds start with Standard. Simple is for smaller MVPs or internal tools. Full is for larger builds where UX and analytics need to be resolved before development starts.
Spending R15k–R60k to avoid the wrong R500k build is the entire point.
Simple
R 15,000
ex VAT // ~2 weeks
For smaller MVPs, internal tools, or early product concepts where the main risk is approving the wrong Phase 1.
- The Go/No-Go Verdict
- Problem & Hook Check
- The Real Phase 1
- A Fixed Build Number
Standard
R 30,000
ex VAT // ~2 weeks
The default for serious builds where the value hook, multiple roles, real data, integrations, compliance, or operating risk could materially change the right Phase 1.
Everything in Simple, plus:
- Friction & Retention Plan
- Admin, Roles & Data Rules
- Running Costs, In Real Numbers
- Risk Register & Roadmap
Full
R 60,000
ex VAT // ~3 weeks
For larger or design-sensitive builds where screens, flows, analytics, and UX need to be resolved before they become expensive development decisions.
Everything in Standard, plus:
- UI Wireframes
- High-Fidelity Mockups
- Analytics & Event Plan
// Not sure which tier? The free 30-minute scoping call confirms it before you commit to anything.
[ CREDIT_MECHANISM ]
Approve the Phase 1 build within 30 days of receiving your Blueprint, and 50% of the Blueprint fee is credited directly to your development deposit. You only pay for that strategic thinking once.
The right starting point if...
- [+]You have an app, internal tool, AI prototype, RFQ, slide deck, or rough idea and are not confident it is ready for a build quote.
- [+]You are not certain the product solves a painful enough problem, or that the brief captures the real value hook and retention mechanic.
- [+]You need a second opinion before committing serious money to development.
- [+]You care that users actually come back after launch, not just that the product demos well.
Probably not, if...
- [-]You already have a production-ready technical spec, stable architecture, and final Phase 1 scope.
- [-]You are still validating whether the problem, audience, or business case is real.
- [-]You are only looking for the cheapest possible quote, regardless of build quality or product risk.
// If your spec is mostly screens, you probably still need a Blueprint. If it is a mapped system architecture, ask us for a build quote directly.
Frequently Asked Questions
You do. The Blueprint and everything in it is yours to keep and use, whether you build with us, build elsewhere, or decide not to build at all. There is no clause that locks the thinking to us.
Yes. We are happy to sign your NDA, or provide a mutual one, before the first session. Most of our work involves other people’s ideas, so confidentiality is the default, not the exception.
That is a valid outcome, and often the most valuable one. If the strongest move is a smaller build, a different model, or "not yet", we say so plainly and explain why. Spending R15k–R60k to avoid the wrong R500k build is the entire point.
No. There is no lock-in. If you do approve the Phase 1 build with us within 30 days, 50% of the Blueprint fee is credited to your development deposit. If you build elsewhere or pause, the document is still fully yours.
Yes. It is written to be build-ready and vendor-neutral, so multiple teams can quote against the same scope. That is usually the first time founders can compare quotes like for like instead of comparing assumptions.
Whatever you already have: an app, RFQ, slide deck, Figma file, or just a clear idea in your head. We pressure-test what exists. You do not need a polished spec, that is often the thing we help you produce.
Two sessions across roughly two weeks (three for the Full tier). Most commercial builds start with Standard. We confirm the right tier together on a free 30-minute scoping call before you commit to anything.
Get a second opinion
before you commit to a build.
We will pressure-test what you have, identify the biggest risk in the brief, and confirm whether Simple, Standard, Full, or no Blueprint is the right next step.
// No lock-in - Fixed pricing - Free 30-min scoping call