A free prototype first. Then a written proposal.
Most software spend does not fail on the code. It fails on scoping, communication, and costs that surface after the work is already underway. Our process is structured to remove each of those risks before you commit budget.
Six things we
guarantee in writing.
No hidden charges
The proposal states the complete cost of the engagement: build, integration, testing, deployment, and handover. There is no discovery fee, no unstated retainer, and no line item that appears after signing. If scope genuinely changes, it is priced in writing and approved by you first.
Proof before payment
The prototype exists before any development budget is committed. You are evaluating working software, not a slide deck. If the direction is wrong, you have lost nothing and you owe nothing.
Written scope, always
Every engagement has a technical sheet and proposal. What is included, what is excluded, what it costs, and when it ships. Verbal agreements are not part of how we work, because misalignment discovered late is expensive for both sides.
You own everything
Repositories in your organisation, cloud accounts under your ownership, intellectual property transferred on payment. We are not building a platform that only we can operate.
Senior engineers throughout
The people who scope the project are the people who build it. There is no account layer between you and the engineering, and no junior learning on your budget.
Honest answers
If a request will not serve you, we say so before building it. If the existing system should be kept rather than replaced, we say that too. Losing an argument early is cheaper for both sides than building the wrong thing well.
From first call
to production.
Conversation
Day 1A call to understand what you are trying to build, what exists today, and what is actually blocking you. No deck, no qualifying funnel. If we are not the right team for the problem, we say so in that call and point you somewhere better.
- --Shared understanding of the problem
- --Honest assessment of fit
- --Rough scope direction
Free working prototype
Days 2 to 10We build the core workflow of your system and put it in front of you running. Not a clickable mockup. Real interface, real data structure, real behaviour. This is how you find out whether we understand your business before any budget is committed.
- --Running prototype of the core workflow
- --First pass data model
- --Concrete discussion instead of abstract requirements
Technical sheet and proposal
Days 10 to 14A written document covering scope item by item, architecture, stack decisions and why, milestone timeline, assumptions and exclusions, complete cost breakdown, and post launch terms. Everything that will be billed is in that document.
- --Technical sheet with architecture and stack rationale
- --Line item scope with exclusions stated
- --Fixed cost and milestone timeline
- --Support terms after launch
Build in cycles
Project durationShort iterations on a working staging environment you can access throughout. You review progress in the product rather than in a status report. Scope changes are priced in writing and approved before work starts.
- --Accessible staging environment from week one
- --Weekly progress visible in the product
- --Written approval before any scope change
Quality gates
Before launchFunctional testing against the agreed scope, performance testing at realistic data volume, and a security review covering access control, input validation, dependency audit, and secrets handling. Nothing reaches production without passing these.
- --Signed off functional scope
- --Performance results at production scale
- --Security review with findings resolved
Launch and handover
Launch weekDeployment, monitoring, alerting, and a handover session. Repositories, cloud accounts, and intellectual property are already in your ownership. Architecture documentation is delivered with the system rather than reconstructed later.
- --Production deployment with monitoring live
- --Architecture and environment documentation
- --Handover session with your team
Support and continued development
OngoingA named engineering lead, defined response times, scheduled dependency and security updates, and continued feature development as the business changes. Or a clean handover if you take engineering in house.
- --Named engineering lead
- --Defined response times by severity
- --Continued development under the same agreement
Two documents,
no ambiguity.
Before development starts you receive both. Together they answer every question we have ever been asked after a project went wrong elsewhere.
The Technical Sheet
- --Proposed architecture with a diagram of components and data flow
- --Data model covering entities, relationships, and key constraints
- --Stack recommendation with the reasoning and trade offs stated
- --Integration points with existing systems and third parties
- --Security and access control approach
- --Infrastructure and deployment plan
- --Performance and scaling assumptions
- --Known risks and how each is mitigated
The Proposal
- --Scope of work item by item, in plain language
- --What is explicitly excluded, so nothing is assumed
- --Milestone timeline with dates rather than a single delivery estimate
- --Complete cost breakdown with the total stated
- --Payment structure tied to milestones
- --Change request process and how changes are priced
- --Support and maintenance terms after launch
- --Ownership of code, accounts, and intellectual property
What usually goes
wrong elsewhere.
| Stage | Common practice | Simply Plugged |
|---|---|---|
| Before budget | Discovery fee to produce a slide deck and estimate | Free working prototype of the core workflow |
| Scoping | Verbal agreement, scope refined during the build | Written technical sheet and proposal, signed before work |
| Costing | Estimate with an hourly rate and a caveat | Fixed cost with a line item breakdown and exclusions |
| Changes | Discovered mid project, absorbed or billed later | Priced in writing and approved before any work begins |
| Team | Senior on the pitch, juniors on the build | The people who scope are the people who build |
| Handover | Documentation as an optional extra | Architecture docs and handover session included |
| Ownership | Vendor hosts, vendor holds the accounts | Repositories and cloud accounts in your ownership |
| After launch | Relationship ends at deployment | Support terms stated in the proposal, no lock in |
Get a working prototype
before you commit budget.
Send us what you are trying to build. We will come back with a scoped technical sheet, a written proposal with every cost stated up front, and a free prototype of the core workflow so you can evaluate real software rather than a sales deck.