The Customer Offer
Hadto analyzes how your business runs day to day, designs a business operating system around it, and finances the build. There is no implementation fee. You pay a monthly operating fee, and in return you get a system that is hosted, supported, watched, and improved by the people who built it. Your business knowledge stays yours, in a form you can take with you: your data, your documented processes, your decision rules.
We finance the build and recover our investment through the operating fee. That is the whole mechanism, and we say it in exactly those words.
The 12-month initial term does not recover our investment. In the example below, the first year bills $84,000 of operating fee against $105,000 invested, and that fee is also carrying hosting, support, and operating cost. Recovery actually happens over roughly the first two to four years, through renewal. We say this up front for a hard commercial reason: a customer who believes we broke even at month 12 reads every invoice from month 13 onward as pure margin, and resents it.
Two consequences follow from the multi-year recovery window. First, we underwrite every engagement before we finance it, and we can decline: a financier who cannot say no is not underwriting. Second, if the acceptance warranty fails and we cannot cure it, we absorb the implementation loss. A warranty whose failure cost lands on the customer is not a warranty.
The software is ours; the business is yours; you can leave with your business.
You own your data, the Business Operating System Blueprint, your process documentation and runbooks, your decision rules, and your baseline metrics. Hadto owns the software platform, the source code, and the reusable modules. We keep the software because reuse across deployments is where our economics come from; you keep everything specific to running your company, because otherwise licensing instead of owning would be a trap.
Exit terms sit here in the offer, not buried in the contract: on termination you receive your data exported in usable formats, the full process documentation, and a defined transition period — 90 days is the illustrative figure — with support during handover. Licensing a system you do not own is a dependence decision, and visible exit terms are the price of asking you to make it.
One example engagement is used everywhere numbers appear on this site, so you can check any page against the same numbers:
| Item | Value |
|---|---|
| Discovery | $20,000 |
| Software design and development | $70,000 |
| Integration and deployment | $15,000 |
| Total Implementation Value | $105,000 — funded by Hadto, not billed to you |
| Monthly operating fee | $7,000 = Base Platform Fee $2,500 + two Managed Applications at $2,250 each |
| Initial term | 12 months |
The implementation value is shown for transparency. It is a defensible market-rate estimate of what this build would cost, and it has to survive scrutiny on scope, complexity, integrations, labor rates, and delivery risk. It is what we are actually investing, not a number inflated to make the financing look generous.
The monthly fee has three parts: a Base Platform Fee of $1,500 to $3,000 that pays for shared infrastructure, account management, monitoring, security, common AI services, maintenance, and standard support; a Managed Application Fee of $1,000 to $4,000 per application per month; and usage and complexity adjustments for things like high AI usage, transaction volume, 24/7 coverage, and integration count.
The resulting bands key to what we operate, and to nothing else:
Your revenue never sets the band. The fee prices an operated system, so its drivers are the cost and criticality of operating it; pricing by revenue would mean charging two customers different amounts for the same system, and that fails the first diligence conversation a careful buyer runs.
One more rule sits on your side of the trade. Before we propose, discovery has to identify roughly three to five times the annual contract value in credible operational value: labor recovered, errors avoided, capacity unlocked. The example's $84,000 first-year contract needs roughly $250,000 to $420,000 of credible value behind it. I think of the multiple as our margin of safety on your side of the table: renewal is our recovery mechanism, and a customer whose plausible upside only marginally clears the fee will not renew through a soft quarter.
The offer is built for owner-led service businesses with $2M to $20M in revenue and 10 to 150 employees, running recurring workflows with multiple handoffs on fragmented software and spreadsheets, with the margin to support a $2,500 to $12,000 monthly fee and leadership willing to enforce adoption. Revenue appears here as a qualification signal and nowhere else. It never sets a price. Each part of the profile maps to a failure mode we cannot underwrite around: too small and the fee has no margin to sit on; too large and procurement wants owned code; no owner authority and adoption stalls; no fragmentation and there is nothing for the platform to consolidate.
The Blueprint is the load-bearing document of the whole engagement: discovery produces it, you sign it, the contract scopes to it, implementation builds to it, acceptance tests against it, and you keep it if you leave. Every dispute an engagement like this can generate (scope, warranty, acceptance, exit) resolves by reference to some document, and concentrating that authority in one signed document you own is cheaper and safer for both of us than arguing it across proposals and emails.
The warranty is material conformance to the signed Blueprint and its acceptance criteria, tested in the 30-day acceptance period, with a defect process, a cure period, and your right to terminate if a material failure goes uncured. It excludes changed requirements, missing data or access, third-party service failures, misuse, poor adoption, and KPI underperformance alone. It never guarantees revenue, labor, or margin outcomes, because baseline improvement depends on adoption. The exclusion list is what keeps the promise honest enough that we can afford to absorb it when it fails.
Every post-launch request lands in exactly one of three classes:
The classes are separable because each has a different payer and a different paper trail. Ambiguity between them is where fixed-fee software engagements traditionally lose their margin and their customer goodwill at the same time.
Getting your team to actually use the system is our job, with defined obligations: training milestones at launch, usage visibility reported in every operational review, and a defined intervention (retraining, workflow adjustment, or owner escalation) when usage drops below the level the baseline metrics assume. Our recovery depends on renewal, and renewal depends on usage, so we do not get to treat adoption as your problem. The warranty still excludes adoption-driven dissatisfaction, but only as the residue after we have done that work.
The fee does not step down after the investment is recovered, because it was never a loan payment. It prices the operated system: hosting, support, security, AI operations, continuous improvement. Financing recovery simply happens inside the early years of it. What changes over time is what the same dollars buy: after recovery, the fee funds continued improvement and platform investment, so the system gets more capable while the price holds. There is no second implementation charge for the original scope, ever. Expansions add priced increments.
The defensible market-rate value of the full implementation (discovery, software design and development, integration and deployment), funded by Hadto. $105,000 in the canonical example. It is an investment we make, not a price.
The $1,500–$3,000 monthly component paying for Hadto-operated shared infrastructure. $2,500 in the canonical example. Excluded from all participation bases.
The $1,000–$4,000 per-application monthly component. $2,250 per application in the canonical example.
The signed discovery output: domain model, process maps, baseline KPIs, MVP scope, acceptance tests, exclusions. Owned by the customer.
We finance the builds we take on, and we recover that investment only if the system keeps earning your renewal. If the trade reads right for your company, start the fit check. We score every submission, qualified fits move to funded discovery, and if it is not a fit right now we say exactly that.