Process
A practical path from idea to production.
Six stages, each with a clear purpose and clear outputs. We adapt the depth of each one to the project — a focused tool needs less ceremony than a regulated platform — but we don’t skip them.
Discover
Understand the business, the users and what success looks like.
Before anyone talks about technology, we learn how the work actually happens today — who does what, where time is lost, which systems are involved and which constraints are fixed. Most expensive mistakes in software are made here, by building the wrong thing well.
What happens
- Stakeholder and user conversations
- Review of existing systems and data
- Walkthroughs of current processes
What you get
- Problem statement and goals
- Known risks and constraints
- An honest view on whether custom software is the right answer
What we need from you
Time with the people who do the work, and access to any existing systems.
Define
Requirements, architecture, scope and a roadmap you can plan around.
We turn what we learned into a scope with clear priorities: what goes into the first release, what waits, and why. We make the key architecture decisions early and write them down, so the reasoning survives beyond the people in the room.
What happens
- Prioritised requirements
- Architecture and integration design
- Delivery plan and estimate
What you get
- Scope for the first release
- Architecture decision records
- Roadmap, budget range and milestones
What we need from you
Decisions on priorities and trade-offs, with one accountable product owner.
Design
The product experience, tested before it is expensive to change.
We design the flows that matter most first and put them in front of real users as clickable prototypes. Design and engineering work together from here, so what gets designed is what can be built within the budget.
What happens
- User flows and information architecture
- Interface design and prototyping
- Usability testing
What you get
- Tested prototype
- Interface designs ready for build
- A component library the product can grow with
What we need from you
Feedback on prototypes, and access to users for testing.
Build
Engineering in short cycles, with working software to review every sprint.
We build in one- or two-week cycles and show working software at the end of each. Code is reviewed, tested automatically and deployed to a staging environment you can use. You own the repository and can see progress at any time.
What happens
- Frontend, backend and integration engineering
- Automated testing and code review
- Infrastructure as code
What you get
- Working software every cycle
- A staging environment you can use
- Documentation written as we go
What we need from you
Regular demos and quick answers when questions come up.
Launch
Testing, deployment and making sure it holds up in production.
Launch is planned, not hoped for. We test against realistic data and load, rehearse the deployment, set up monitoring and alerting, and plan data migration and rollback before the switch-over.
What happens
- End-to-end, performance and security testing
- Data migration and cut-over planning
- Monitoring and alerting
What you get
- Production release
- Runbooks and handover documentation
- Monitoring dashboards
What we need from you
User acceptance testing, and sign-off on go-live.
Evolve
Support, improvement and scaling once real usage starts.
Real usage shows what matters. We fix what needs fixing, measure how the product is used and plan the next releases from evidence. If you would rather bring development in-house, we hand over properly.
What happens
- Support and maintenance
- Usage analysis and iteration
- Performance and cost optimisation
What you get
- A prioritised improvement roadmap
- Ongoing releases
- A clean handover if you take it in-house
What we need from you
Feedback from users and the business on what to do next.
How working with us feels.
You own everything
Code, designs, documentation and infrastructure live in accounts you control from day one.
Working software, often
Demos every one or two weeks, on a staging environment you can use yourself.
Decisions written down
Architecture decisions and trade-offs are recorded, so the reasoning outlives the meeting.
Plain reporting
What was done, what’s next, what’s at risk and what we need from you — every week.
Estimates you can plan with
Ranges with assumptions stated, refined as uncertainty drops — never a single number pulled from the air.
No lock-in
Mainstream tools and documented systems, so another team could take over if you ever needed them to.
Ways to work together.
Product build
You have a product or system to create and want one team accountable for it. We take a product from discovery to launch with a dedicated team — strategy, design, engineering and infrastructure — and stay on to support and evolve it.
Embedded engineering
You have a product team and need more senior capacity or specialist skills. Our engineers join your team, work in your tools and follow your process, with the aim of leaving your codebase and your team stronger.
Modernisation
An existing system is slowing the business down, but it can't simply be switched off. We map the system, stabilise it, and replace it piece by piece — keeping the business running throughout.
Have a product worth building?
Tell us what you are trying to achieve. The first conversation is about understanding the problem — not selling you a solution.