Find out what to build before you pay to build it
Spec-first consulting, architecture reviews, and rapid MVP builds for early-stage products. You get a written technical plan, a costed roadmap, and — if it makes sense — a working MVP that tests the riskiest assumption first.
3+
Years shipping production systems
12+
Projects delivered end to end
1
Written spec before any build
Advice grounded in stacks I actually ship on
Why early builds go wrong
Most failed MVPs were built correctly. They were just the wrong build.
The expensive mistake is rarely bad code. It is six months of good code aimed at an assumption nobody tested, on a stack chosen by whoever was available.
I start by writing down the riskiest assumption and the smallest thing that would test it, then recommend a stack sized for that — including saying when the answer is an off-the-shelf tool rather than a build. You leave with a document you can hand to any developer, not a dependency on me.
The problems I get called in to fix:
- 01
A feature list instead of a hypothesis
Twenty features, no statement of what would prove the idea works. Everything is priority one, so nothing is.
- 02
An architecture chosen by habit
Microservices and Kubernetes for a product with no users, or a no-code stack for something that clearly needs custom logic. Both cost months.
- 03
AI added because it is expected
A model bolted onto a workflow where a form and a rule would have been faster, cheaper, and more predictable.
- 04
No idea what the build should cost
Quotes range 5x between agencies because the brief is vague enough that everyone is pricing a different product.
- 05
A codebase the next team refuses to inherit
An MVP written to be thrown away, then not thrown away. Every later feature costs more than the last.
1 wk
To a written technical plan
3
Costed options in every recommendation
0
Vendor lock-in in the deliverable
What consulting and MVP work covers
Advice you can act on, and a build that proves it
Engagements range from a single architecture review to a full MVP. Each one ends in a document you own.
Product & technical discovery
A structured pass over the idea: who the user is, what job the product does, what has to be true for it to work, and which of those assumptions is most likely to be wrong. That last one becomes what the MVP tests.
- User and job-to-be-done framing
- Assumption and risk register
- Success criteria for v1
- Explicit non-goals
Where the advice comes from
Recommendations grounded in systems I have shipped
I only advise on stacks I have run in production. Where a question falls outside that, I say so rather than improvising.
How the work gets sequenced so the risky part is answered early instead of last.
What you walk away with
Deliverables you own, not a dependency on me
Every engagement produces artefacts you can hand to an agency, an in-house team, or an investor.
The written technical plan
A document covering the recommended architecture, the alternatives considered, the data model, the integration surface, and the reasoning behind each decision — so a future engineer can disagree with it on the merits rather than guessing.
- Architecture decision records
- Data model and integrations
- Alternatives and trade-offs
- Risks and mitigations
A costed, sequenced roadmap
Phases with effort ranges, dependencies, and what each one unlocks — so you can fund the next three months rather than the whole vision, and know what you are deferring.
- Phased delivery plan
- Effort ranges per phase
- Dependencies and critical path
- What each phase proves
An MVP that answers a question
A working product scoped to the riskiest assumption, instrumented so the result is measurable. Built on a production stack, with the deliberate shortcuts written down so they can be repaid on purpose.
- Scoped to one testable hypothesis
- Production-grade foundations
- Instrumented for a real answer
- Documented technical debt
An honest build-vs-buy assessment
For each component: build it, buy it, or defer it — with the reasoning and the cost. The most valuable output of a consulting engagement is often the features it removes from the plan.
- Component-by-component assessment
- Vendor shortlist where buying wins
- Deferral recommendations
- Total cost of ownership view
A codebase and team review
For products already underway: a review of the code, the architecture, and the delivery process, with findings ranked by risk and a remediation plan you can actually sequence.
- Code and architecture review
- Risk-ranked findings
- Remediation sequencing
- Delivery process recommendations
Not sure if you need advice or a build?
Most founders book a call expecting a quote and leave with a shorter plan. Book a free 30 minutes: describe the idea, and you will get an honest read on the riskiest assumption, the realistic cost, and whether building is even the next step.
Real builds behind the advice
Products I have specced and shipped
The recommendations come from systems that are running, not from a framework deck. Problem, solution, and my role on each.
Physical AI Robotics Book
AI and robotics learners lacked a structured, accessible documentation platform covering humanoid robotics fundamentals through advanced concepts in a cohesive learning path.
Digital FTE Dashboard
Operations teams managing Digital FTEs across multiple clients had no single view of agent activity, approvals, or system health. Performance data lived in separate tools, Oracle for ERP records and Odoo for invoicing, so reviewing and approving agent work meant switching between several dashboards.
AI Chatbot Builder
Agencies wanted to embed branded AI assistants on client sites but lacked a platform to manage per-client knowledge bases and measure how the assistants actually performed.
Obsidian Plugin Suite
Power users of Obsidian wanted note-taking to handle repetitive workflows automatically instead of relying on manual templates and tagging every time.
Who I work with
Stages where a technical counterpart pays for itself
The advice is the same discipline every time. What changes is how much of the plan is a build.
Pre-seed founders
Non-technical founders who need a plan credible enough to raise on, and small enough to fund now.
- Technical plan for investor conversations
- Realistic cost and timeline ranges
- First-hire role definition
- MVP scoped to one hypothesis
How an engagement runs
From first call to a plan you can act on
Short, structured, and ending in documents you own. Most consulting engagements finish inside two weeks.
Intro call
Free, thirty minutes. The idea, the constraints, the deadline, and the budget reality. If I am not the right person for it, that gets said here.
Deliverables
- Fit assessment
- Scope sketch
- Next-step recommendation
Discovery
A deeper session with whoever holds the domain knowledge, plus a review of any existing code, designs, or documentation you already have.
Deliverables
- Assumption register
- Existing-system notes
- Question list
Options analysis
Two or three viable technical directions, each with effort, cost, risk, and what it forecloses. Recommending one is the job, but you see the alternatives.
Deliverables
- Option comparison
- Cost ranges
- Recommendation
Written plan
The architecture, data model, integrations, and roadmap, written to be handed to any developer. Delivered as a document, then walked through live.
Deliverables
- Technical plan
- Roadmap
- Walkthrough session
MVP scoping
If a build follows, the plan narrows to the smallest slice that tests the riskiest assumption, with acceptance criteria and a fixed scope.
Deliverables
- MVP spec
- Acceptance criteria
- Fixed-scope quote
Build & instrument
The MVP is built in weekly reviewable slices, instrumented so the question it exists to answer is actually measurable.
Deliverables
- Weekly preview
- Instrumentation plan
- Slice demos
Review & decide
What the MVP showed, what it did not, and a recommendation on continuing, pivoting, or stopping — including when stopping is the right call.
Deliverables
- Findings review
- Next-phase plan
- Honest go/no-go
Why work with me
An engineer who will talk you out of work
The recommendation that removes a feature is worth more than the one that adds three, and it is the harder thing for a vendor to say.
You own the deliverable
The plan is written to be executed by anyone. If you take it to another developer, it works just as well — that is the point.
Advice from a builder
I ship the stacks I recommend. Estimates come from having done the work, not from a spreadsheet of industry averages.
Costs modelled, not hand-waved
Hosting, tokens, third-party services, and maintenance are estimated at realistic volumes before you commit to a direction.
Straight answers about AI
Including the frequent one: this workflow does not need a model, it needs a form and a rule, and that will be faster and cheaper.
3+
Years shipping production systems
12+
Projects delivered end to end
1 wk
Typical time to a written plan
100%
Deliverables you keep and own
Frequently asked
Questions people ask before we start
Have an idea and no technical counterpart?
Describe what you are trying to build and what you are unsure about. You will get an honest read on scope, risk, and the smallest next step — for free.