Product Inception
Proof before the money moves.
Product Inception is HoG's paid discovery phase for ambiguous product, platform, workflow, or internal-tool work. It turns the idea into a clickable proof-of-value prototype and a clear implementation path before you commit to the complete build. One to three weeks of prototype-led product definition, with a working artifact at the center. From $10,000.
A working artifact, not a longer document.
Product Inception is paid, prototype-led product definition for opportunities where the product shape and the technical path are still too fuzzy for a responsible build commitment. It puts working software at the center because people react to a prototype honestly — objections, missing context, and false assumptions show up faster than they ever do on a slide.
Clickable proof-of-value prototype
A clickable prototype of the decision-critical part of the product — real enough that you judge the direction by using it, not by imagining it from a document.
Implementation memo
The decisions, assumptions, expensive unknowns, non-goals, and recommended path, captured in plain language — written so whoever does the build can work from it.
Scope boundary
What belongs in the first serious build, what should wait, and what should stay out entirely.
Commercial next step
A practical recommendation: move into the build, change direction, or stop cleanly.
The proof is yours, even if the build isn't ours.
Product Inception is a purchase, not a down payment. Three terms worth stating before any money moves.
What you own
The prototype and the memo, outright, once the invoice is paid. Both keep working without us — if the build happens with another team or in-house, the memo is still the plan and the prototype is still the proof.
What the prototype isn't
Production software. Nothing real runs behind it — no live accounts, no live data — and it isn't something you launch. It's built to settle the decision; the production system is what the build is for.
What it commits you to
Nothing past the readout. Stop, build elsewhere, and continue with HoG are all valid endings, and the recommendation is written to the evidence, not to the sale. If both sides continue, the decisions and implementation memo become the first delivery brief.
A filter for funded ambiguity.
Product Inception is for buyers with enough stakes, uncertainty, and implementation potential to justify paid definition. It's a small engagement, but it isn't a small decision — so here's the honest read on who it's for.
Product Inception makes sense if
you're weighing a serious software product, platform, workflow, internal tool, modernization, or hardware/software opportunity; the ambiguity is high enough that product and architecture judgment matter; a prototype would force better decisions than a written brief alone; and a plausible complete build — $75k and up — exists if the direction is validated.
It doesn't if
- you need a brochure site or commodity CMS and plugin cleanup
- you're shopping low-budget marketing work or comparing hourly rates
- you want the ticket built exactly as written, pushback unwelcome
- the scope is already clear enough to skip this and scope the build directly
Not sure it clears the bar? That's what the fit call is for.Request a fit call
THE PROCESS
How it runs
The work moves from unknown to decision.
Inception ends when the next decision is obvious. We're not trying to design the whole product. We're trying to expose the truth that a complete build depends on.
01
Fit call
We confirm the opportunity has enough stakes, ambiguity, and implementation potential to justify inception.
Checkpoint · Go or no-go on paid scope
02
Source review
We absorb the material you already have and map the customer, the workflow, the product promise, and the constraints.
Checkpoint · Problem frame and proof target
03
Prototype pass
We design and build the decision-critical product surface — the interaction that has to be believed.
Checkpoint · Clickable proof surface
04
Stakeholder review
We put the prototype in front of your stakeholders to surface objections, missing context, buyer reactions, and implementation traps.
Checkpoint · Validated and challenged assumptions
05
Implementation memo
We convert the prototype work into decisions, expensive unknowns, non-goals, dependencies, and recommended next steps.
Checkpoint · Build path or stop signal
06
Readout
We walk through what the prototype proves, what it doesn't, and whether the build is worth funding.
Checkpoint · A clear next commercial decision
What the studio ships
A prototype is useful only if it changes the decision.
The artifact gives everyone something concrete to react to: the product story, the expensive technical unknowns, and the commercial case. Three questions run through the whole engagement.
Product
Does this workflow create the right kind of value for the right audience?
Technical
Where could the architecture or integrations create expensive surprises?
Commercial
Is the opportunity strong enough to justify a complete build?
The investment
Fund the proof before the build.
From $10,000 · One to three weeks
Product Inception is sized to make the decision real without pretending you're ready for full implementation spend. The floor covers a focused one-week pass around one decision-critical question; larger opportunities scale from there. The point of spending $10,000 is to protect the $75k-plus complete-build decision behind it.
What moves the number
Prototype depth and fidelity, stakeholder complexity, the quality of the source material you already have, integration and workflow uncertainty, and how deep the memo needs to go. We'll put a number on it after the fit call, not before.
How engagements are pricedIf the idea is serious but the build path is still fuzzy, start here.
We'll tell you on the call if Product Inception is the right first move — or if you can skip it and scope the build directly.
Free · Thirty minutes · Reply within one business day