How we work
How we work
Every project moves through six stages. The depth of each stage depends on the project — a landing page compresses this path; a multi-user application expands it.
Learning first in unfamiliar domains
Many projects touch a domain we have not worked in before — that is normal. We learn the terminology and real workflows, identify our assumptions, validate requirements with the people who know, and work alongside domain experts until the system reflects how the work is actually done.
Delivery process
Discover
- What happens
- We talk about your goals, the people involved, your current workflow, and the constraints around budget, time, and technology.
- What you contribute
- Time for one or two conversations, honest context about how things work today, and access to the people who use the systems.
- What comes out of it
- A shared understanding of the problem, written down and confirmed with you.
Define
- What happens
- We turn that understanding into concrete requirements, priorities, and success criteria, and agree what is out of scope.
- What you contribute
- Decisions on priorities and a clear answer to what success looks like.
- What comes out of it
- A scope agreement you can hold us to — and we can hold you to.
Plan and design
- What happens
- We design the user journeys, page or screen structure, technical architecture, and the visual direction.
- What you contribute
- Feedback at agreed checkpoints and examples of what you like or dislike.
- What comes out of it
- A design and structure you have approved before significant build effort begins.
Build
- What happens
- We implement in iterations, showing you working results at agreed review points instead of disappearing until the end.
- What you contribute
- Prompt reviews and real content or test data when it is needed.
- What comes out of it
- Working software, reviewed increment by increment.
Test and launch
- What happens
- We test the real workflows end to end, fix what we find, deploy, and walk you through everything that changed.
- What you contribute
- People willing to test realistic scenarios and report what feels wrong.
- What comes out of it
- A launched solution and a documented handover you own.
Improve
- What happens
- After launch we fix defects, monitor, and make agreed improvements. This stage is optional and agreed separately.
- What you contribute
- Feedback from daily use and a decision on whether ongoing support makes sense.
- What comes out of it
- A maintained solution — or a clean, independent handover if you prefer.
Every project moves through these six stages — but a focused landing page moves faster than a multi-user application. We shape the plan around your project, not the other way around.
How we run projects
- Scope and changesThe scope agreement lists what is included. New ideas are welcome — they are estimated and agreed before work continues, so there are no silent budget changes.
- Communication and feedbackYou talk directly to the person building your solution. We agree a rhythm of updates and reviews at the start, and you never wait weeks to see progress.
- Dependencies and accessSome work needs accounts, content, or decisions from your side. We flag these early and agree who provides what, because waiting on access is the most common source of delay.
- TestingWe test with realistic scenarios before anything ships, and we ask your team to do the same. Automated checks are added where they genuinely reduce risk — not for their own sake.
- Handover and ownershipYou own what we build. Code, content, credentials, and documentation are handed over in full, and we make sure you can run the solution without us.
- Optional ongoing supportIf you want continued maintenance, monitoring, or improvements after launch, we agree a support arrangement explicitly. You are never locked in.
Understand first. Build what matters.
Ready to talk about your project?
Bring a goal, a problem, or a rough idea — the first conversation is about understanding, not selling.