How we work, step by step.
Every engagement runs through the same seven stages. It is deliberately unglamorous: it means you always know which stage you are in, what is being produced, and what happens next.
Discover
Understand the business before touching the software.
We start with the problem, not the feature list. Structured sessions with the people who will actually use the system, a walkthrough of how the work is done today, and a written account of the constraints that are non-negotiable - regulatory, operational and budgetary. Nothing is estimated until we can describe your process back to you accurately.
Define
Turn understanding into an agreed, written scope.
We convert discovery into a scope document: what is being built, what is explicitly out of scope, what the acceptance criteria are, and what assumptions the estimate rests on. Where the requirement is genuinely uncertain, we say so and price it as a separate discovery phase rather than burying the risk in a number.
Design
Interface and architecture, decided before code.
Information architecture, user flows and interface design in parallel with the technical architecture - data model, integrations, access control and hosting shape. You review real screens, on real devices, before a line of production code is written. Design decisions are recorded so they can be revisited deliberately rather than drifting.
Build
Short iterations, working software, visible progress.
Development runs in short iterations against the agreed scope. You get access to a staging environment from the first iteration, so progress is something you use rather than something you are told about. Code is reviewed, version-controlled and documented as it is written, and scope changes are handled as explicit, priced change requests.
Test
Prove it works before anyone depends on it.
Functional testing against the acceptance criteria, cross-device and cross-browser verification, performance checks under realistic load, and a security pass covering authentication, authorisation, input validation and data exposure. You run user acceptance testing on staging with real scenarios, and defects are triaged and tracked to closure.
Deploy
Go live as a planned event, not a leap of faith.
Production environment provisioning, configuration and secret management, data migration where relevant, monitoring and backups, and a documented rollback path. We agree a launch window, run through a pre-launch checklist, and stay on hand through the first live period. Handover includes documentation, credentials and a walkthrough for your team.
Support
The relationship continues after launch.
A defined support arrangement with agreed response expectations, dependency and security patching, monitoring and uptime checks, and a route for enhancement work. Most of our clients keep building - support turns into the next phase of the roadmap, planned on the same discover-define-design rhythm rather than as ad hoc requests.
Understand the business before touching the software.
Written scope, always
Nothing starts without an agreed scope, acceptance criteria and a phase plan. Verbal scope is how projects fail.
You own the work
On final payment, intellectual property in the bespoke work transfers to you, with source code and documentation handed over.
Staging from day one
You watch the product get built. There is no long silence followed by a reveal.
Change is priced, not absorbed
Scope changes are welcome - they are quoted and agreed rather than quietly extending the timeline.
One accountable lead
A single point of contact who knows the project, backed by the specialists it needs. No account-manager relay.
Confidentiality by default
NDAs signed on request, client data never reused, and nothing published without written permission.