How we work

A process built to be interrupted.

Every stage produces something you can review, question and stop. If a project is going wrong you should find that out at the end of a two-week stage, not at the end of a six-month build.

Stages
Seven, each with outputs
Review cadence
Weekly, against live software
Typical span
5 to 12 months
Exit points
End of any stage
01

Discovery

2-4 weeks

We map the operational problem, the people who live with it and the metric that would prove it solved, then cut scope to what can actually ship. Most discovery work is subtraction.

  • Problem statement
  • User map
  • Success metric
  • Scoped backlog
02

UX & UI Design

3-6 weeks

Complete flows for every user type, prototyped and tested before a line of production code. We design the empty, loading, error and offline states too, because that is where most products fall apart.

  • Flows and wireframes
  • Interactive prototype
  • Design system
  • Accessibility spec
03

Frontend & Mobile

6-14 weeks

Designs become real, interactive product. Web and native builds go onto real devices from week one, so the feedback loop runs against something you can hold rather than a slide.

  • Component library
  • Working builds
  • Device test matrix
  • Performance budgets
04

Backend & Platform

6-16 weeks

APIs, data models, authentication and integrations. We settle the tenancy and permission model early because everything downstream inherits from it, and retrofitting it is expensive.

  • API contracts
  • Data model
  • Integration layer
  • Security review
05

Testing & Hardening

3-5 weeks

End-to-end tests across real devices and environments, load testing against realistic volumes, and a security pass. Bugs get found here rather than by your users in week one.

  • Test suites in CI
  • Load test results
  • Security findings
  • Fix log
06

Launch

2-3 weeks

App stores, cloud or on-premise, deployed with monitoring, alerting and a rollback plan written before it is needed. Rollout is staged, never a single switch.

  • Deployment pipeline
  • Monitoring and alerts
  • Rollback plan
  • Runbook
07

Maintenance & Upgrades

Ongoing

Hosting, updates, fixes and new features, or a clean handover to your own team with the documentation to make that realistic. Both are normal endings.

  • Support agreement
  • Handover docs
  • Roadmap
  • Training

Questions we get asked first

Yes, and some clients should. Discovery is a fixed-scope engagement that produces a written problem statement, a scoped backlog and an honest estimate. If that document says the project is not worth building, or that an off-the-shelf tool already covers it, we will say so and the engagement ends there.
You do, from the first commit. Repositories sit in your organisation, cloud accounts are yours, and infrastructure is defined as code you can read. There is no proprietary runtime you need us to keep running, and no retainer required to keep the product alive.
Per stage, not per project. A twelve-month estimate given in week one is a guess dressed as a commitment. We estimate the next stage precisely and the remainder as a range, then tighten that range at each stage boundary as real information arrives.
They will, and the stage structure exists partly for that. Changes are priced and scheduled at stage boundaries rather than absorbed silently, which keeps the trade-off visible: something new comes in, so something else moves out or the stage gets longer.
Often. We can run as an embedded team beside your engineers, or take a defined component and hand it back with documentation and a walkthrough. Where your team will maintain the result, handover is built into the schedule rather than treated as an afterthought.
Start here

Start with the smallest useful stage.

Discovery is fixed-scope and produces a written output. If that document says you should not build the thing, that is a good result, and the project ends there.