Pricing
What the work costs.
We price engagements, not time. The ranges are published so you can decide whether this is your kind of engagement before you talk to anyone.
THE LADDER
A sequence, not a menu.
The call scopes the work. Product Inception proves an ambiguous idea. Monthly delivery or an embedded partnership carries the work after that. If equivalent definition already exists, Product Inception can be skipped.
№ 1
Fit callFree
Thirty minutes. You describe the product, we give you an honest read on fit and the shape of the work. Free either way. If the answer is no, we'll say so and point you somewhere better.
№ 2
Product InceptionFrom $10,000
One to three weeks of prototype-led product definition. You get a clickable proof-of-value prototype and an implementation memo. That's enough real software to answer the question that could sink the project, before the money moves.
About Product Inception№ 3
The engagement
One rung, two shapes. The product decides which; the call is where that gets read.
Monthly deliveryFrom $25,000 per delivery month
Typical complete build $100k–$200k · Complete-build envelope $75k–$250k · Four to five delivery months
Monthly delivery is for a complete build with a defined destination. Each delivery month has one fixed fee, one invoice, an agreed result, and a monthly review. We set one engagement-specific monthly fee and hold it through the expected build unless the team shape or commercial commitment changes materially. The plan can change through recorded decisions; the result and quality bar do not.
- What gets builtTwo to four weeksWhat gets built, what waits, and what gets cut.
- How it worksThree to six weeksWe do the research and design the interface before anyone writes the code behind it.
- How it holds upSix to twelve weeksWe build it on architecture that survives real use.
Embedded partnership$8k–$20k/month
Three-month minimum
An ongoing retainer: senior engineering inside your team, carrying an existing product and its roadmap month over month. Fractional engineering leadership is the same engagement by another name. Most partnerships are continuity: a build goes live, and the people who made its decisions stay with the product. Partnerships have a three-month minimum, enough time to absorb a codebase and be accountable for it. The longest has run four years.
How the numbers work
Ranges come with reasons.
What moves a complete build within $75k–$250k
How much product has to exist at launch, how many kinds of user it serves, how many systems it integrates with, whether it touches hardware or the physical world, and what compliance asks of it. A typical complete build lands around $100k–$200k, normally four to five delivery months.
Why ranges, not tiers or hours
We price monthly delivery around the result we agree to, not around hours or rented capacity. A delivery month buys HoG's accountability for that result under one fixed fee. The plan can move as the product teaches us more, but the move gets recorded: what changed, what enters, what leaves, and what still has to hold.
What phases do and do not do
What gets built, how it works, and how it holds up are lifecycle stages. They help organize the work, but they are not billing units. A delivery month can cross a phase boundary. Phase changes go into the delivery brief, decision log, and review record; they do not create invoices by themselves.
When HoG still owes the result
If we materially miss the agreed result, the next delivery month does not start. We finish what we owe under the fee already paid. When the client accepts the work and both sides agree to continue, the next delivery month begins. We invoice each delivery month when it starts unless the client's procurement rules require another schedule.
Where the partnership fits
Monthly delivery is for a bounded product result that gets accepted before the next month starts. The partnership, at $8k–$20k/month, is for an existing product, an ongoing roadmap, or fractional engineering leadership. It carries continuity and senior ownership, but it does not promise a separately accepted build result every month.
Who's accountable at these numbers
Every engagement is principal-led. Dom scopes the work on the call, owns architecture and the major product calls through the build, and reviews what gets deployed. The person who priced the engagement is the person on the hook for it in production. Where a build needs more hands, specialists come from a small set of recurring collaborators for things like design, UX, and extra engineering capacity. We contract for a defined role and a booked block of time. Nobody is held on standby; capacity is scoped into the proposal before you sign, naming the actual people rather than a bench chart. Their work lands in your repository, inside the same written decision log, and clears the same review before release. Continuity, committed capacity, and exclusions are engagement terms, not website copy: raise them on the call and they get answered in the proposal, in writing.
Where this isn't the answer
If you're comparing hourly rates, we can't give you one, and a studio that bills by the hour will answer your question better. If you expected a tier picker, there isn't one, our work doesn't come in sizes. If you need a brochure site, this is more capability than the job wants, and it can be done well for far less elsewhere. None of that is a judgment on the work. It's triage, and it runs in both directions.
What the studio ships
That's every number we have. The next step is a conversation about your product, not a negotiation.
Free · Thirty minutes · Reply within one business day