Build
Software at the speed of your ideas.
Production-grade software, fixed price, delivered in weeks. We scope it against a signed done-test, then build it with the delivery risk on us: the signed done-test delivered in full, or your money back.
Production-grade means hardened for security and errors, observable, GDPR-ready, and accessible. The signed done-test records which of those layers each delivery includes.
What it costs
Engagements start small on purpose. Where you start depends on whether there is already something to look at.
If you have a system already
A free Codebase X-Ray reads it and reports what a machine can prove. Then, usually, a first fixed-price piece under £6k, carrying the same signed done-test and the same money back as a full build.
Start with an X-RayIf you are starting from scratch
A shaping pass turns your brief into a spec and a signed done-test. It is priced against how much shaping it needs, and costs nothing at all if you arrive with a done-test-ready spec of your own. The spec is yours whether or not we build it, and the fixed price for the build comes with it.
Take the templates firstEither way, the build that follows is priced against your signed done-test and delivered as several fixed-price pieces. You stop at any boundary.
What moves the price
How much done you are buying
A build chasing product-market fit is scoped for speed. Security hardening, observability, GDPR and accessibility are scoped and priced when the thing is worth hardening. The done-test records which one you bought.
How much of it there is
A larger programme is several fixed-price pieces, each with its own done-test. You stop at any boundary.
How much has to connect
Third-party systems, data sources, and migrations from whatever holds the data now. Integration count moves a price further than feature count does.
How the fixed price works
Shaping pass
A short paid engagement turns your brief into a detailed spec and the signed done-test. The spec is yours, and the fixed price for the build comes with it.
Signed done-test
An objective, demonstrable definition of done, written together and signed by both sides. It records which hardening layers each delivery includes.
Fixed price, paid up front
The price commits only once the done-test is signed. A stage is paid before it starts. Scope changes are a written change request with a revised price and done-test.
Money back
If a check misses at the demo, we fix it at our cost until it passes. If we cannot get there, that stage's fee comes back in full and its work and IP revert to us. Earlier stages you accepted are untouched. Time overruns are ours to absorb, never yours to fund.
The full mechanism is Step 0 of how we work.
You can read the instrument itself before you speak to us: the done-test explained, with both templates, published in full and free to take.
How We Engage
Every customer's situation is different. These are the build engagements we offer, each one scoped independently, priced upfront, and delivered against a signed done-test.
Shaping Pass
The paid first step of every build
- Turns your brief into a detailed spec and a signed done-test
- For legacy systems: includes discovery with codebase access, demonstrably deleted afterwards
- Output: spec, signed done-test, and a single fixed price
Rapid Prototype
2–5 days, validate before you commit
- Working prototype to test assumptions and gather early feedback
- Non-production: focused on UX, UI, and concept validation
- De-risks the full build before the big spend
MVP Build
Full-stack delivery in weeks
- Frontend, backend, infrastructure, and deployment
- Built to extend: no rewrite needed when you scale
- CI/CD, automated testing, and documentation from day one
Post-MVP Milestones
Ongoing feature delivery against a live product
- Each milestone is a new fixed-price engagement with clear scope
- Continuous delivery against a prioritised backlog
- Same mechanism: fixed price against a signed done-test, delivered in full or money back
Legacy Refactor & Migration
Old tech to modern stack, incrementally
- Any language, any platform; we assess what you have and plan the path
- Incremental migration, not big-bang rewrites
- Data migration with validation, rollback, and zero downtime
API & Integration Builds
Connect your systems, build partner APIs
- Third-party platform integration and custom API development
- System-to-system connectivity and data synchronisation
- Documented, versioned, and production-ready
AI Agents & Automation
Intelligent workflows that work with your data
- Bespoke AI agents, LLM integration, and RAG pipelines
- Process automation that eliminates manual, repetitive work
- Built with guardrails: reliable, auditable, and safe
Some work cannot be scoped up front: an experiment, a spike, a question that has to be answered before anything can be specified. We do that on a metered basis, in quarter-day units, scoped and timeboxed before it starts. It is a small part of what we do, and we will tell you when it is the right answer. Everything else is fixed price.
Technical due diligence and security assessments live under Assess.
What We Work With
Technology-agnostic. We work across languages, frameworks, and platforms.
How It Works
We carry the delivery risk, so we control the delivery process. Every change runs the automated quality gates: tests, security scans, and CI, on every commit. Your review happens at milestone sign-off, against working software. For ventures we believe in, we can share in the upside instead of charging full price.
Shaping
We resolve design decisions, scope, and the done-test upfront in a paid shaping pass, so the build is de-coupled from your team. For greenfield projects, we shape from your brief. For legacy systems, shaping includes discovery with access to your codebase to map the landscape first; all code access is demonstrably deleted afterwards.
Prototype
We build a working prototype where it de-risks the approach before committing to the full build. You see something real before the big spend.
Build milestones
The build is split into milestones, each with a concrete delivery. You see working software at each stage.
Productionisation
Final hardening: extended testing, security controls, deployment, and documentation. Source code and IP assign to you as each stage is paid, so ownership builds up as you go rather than waiting on a final handover. No lock-in.
Warranty & beyond
Every delivery includes a warranty period: bugs against the signed done-test are fixed at no cost. After that, ongoing support is a production support agreement, a new fixed-price engagement, or a reserved-capacity retainer.
Why Mangrove
- AI-native delivery: a senior lead directing frontier models, with specialists on demand, delivering production software in weeks
- Secure by architecture: 20+ years in cybersecurity; scanning and isolation on every build
- Regulation-ready: GDPR, FCA-grade data, audit trails designed in, not bolted on
- Full ownership: source, docs and IP assign to you stage by stage as each is paid. No lock-in
- Fine-grained control: stop, re-scope, or continue at every stage boundary. The done-test is yours; changes are written; nothing moves without your sign-off.
Fixed priceSigned done-testDelivered in full or money back
Have a project in mind?
Send us your spec or idea. We'll come back with a clear scope and a fixed-price proposal. If the scope needs shaping, we'll propose a short paid shaping pass that turns it into a signed done-test and a fixed price. No obligation.