The code is yours
All source code, design assets and admin access transfer to you when the project closes.
Process
Doing the right work, in the right order.
Every project has its own context. A clear process keeps everyone moving in the same direction. Here is how we work end to end: what happens at each stage, what you receive, and how much of your time it takes.
- 3
- Phases: frame, build, operate
- 6
- Stages, each with defined deliverables
- 2 weeks
- One cycle: demo, then re-set priorities
- 2020
- A process shaped by real projects since
The shape of it
Three phases, six stages.
The six stages group into three phases. Each phase ends with a clear decision, so nobody has to keep building on an unsettled foundation.
01Frame
Discover · Frame
Understand the problem before discussing solutions. By the end of this phase, scope, roadmap and measures of success are agreed in writing.
Scope and roadmap agreed
02Build
Design · Build · Verify
Design and code progress in slices you can see. You get a working product every two weeks instead of waiting until the end.
A working, accepted product
03Operate
Launch & support
A controlled release, a full handover so your team is self-sufficient, and continued monitoring and improvement after go-live.
Your team can run it alone
Six stages
Every stage, in detail.
The durations below are typical ranges. Exact timing is confirmed against real scope right after discovery.
01
Discover
Typical duration1–2 weeks
Clarify goals, users, constraints and measures of success before discussing any solution.
What we do
- Talk with stakeholders and the people who will use the product
- Review the systems, data and processes already running
- Identify risks, technical constraints and how success gets measured
What you receive
- A written requirements record with measurable goals
- A risk list with how each one will be handled
- A scope proposal with an initial estimate
Your involvement2–3 working sessions and access to the operational detail.
02
Frame
Typical duration1 week
Define scope, information architecture and the delivery roadmap so both sides commit to one plan.
What we do
- Sort scope by priority: now, later, not at all
- Shape the information architecture and the core business flows
- Plan a roadmap of increments you can review and try
What you receive
- Scope and information architecture documents
- A staged roadmap with delivery milestones
- A team plan and the shared working channels
Your involvementOne person who can decide on scope and priority.
03
Design
Typical duration2–4 weeks
Shape the experience, interface and prototypes for early validation, while changes are still cheap.
What we do
- Wireframe the core flows, including the edge cases
- Design the interface on a reusable component system
- Build interactive prototypes to test with real users
What you receive
- Design files with a component system
- Interactive prototypes of the core flows
- Design notes handed over to the engineers
Your involvementFocused feedback across 2–3 review rounds.
04
Build
Typical durationScope-dependent, in 2-week cycles
Develop in visible increments that can be reviewed and tested, rather than saving everything for the end.
What we do
- Every two-week cycle ends with something that runs
- Peer code review before anything is merged
- A staging environment kept current so you can follow along
What you receive
- A staging environment you can access throughout
- Source code with a clear, readable change history
- A demo and change notes after every cycle
Your involvementAround 60 minutes every two weeks to review and re-set priorities.
05
Verify
Typical durationContinuous, tightened 1–2 weeks before launch
Review functionality, content, performance and accessibility on real devices and browsers.
What we do
- Functional testing against real business scenarios
- Measure and tune performance on desktop and mobile
- Review accessibility, technical SEO and content
What you receive
- A test report with the status of every issue
- Performance measurements before and after tuning
- A signed-off pre-launch checklist
Your involvementAcceptance against the checklist agreed up front.
06
Launch & support
Typical duration1 week to launch, support as agreed
Release with care, enable the team and keep improving alongside them.
What we do
- Launch to plan, always with a rollback path
- Hand over source code, documentation and admin access
- Train the operating team and watch closely after go-live
What you receive
- Operating documentation and admin guides
- All source code, design assets and access credentials
- Maintenance and support scope agreed in writing
Your involvementName an internal owner to take over operations.
Working rhythm
You always know where the project stands.
No multi-week silence followed by a surprise. This is our default rhythm, and it adapts to how your team already works.
- DailyOne direct channel
A shared channel with the person running your project. Questions asked in working hours get answered the same day.
- WeeklyA one-page progress note
Done, in progress, and the decisions waiting on you. Short, and free of jargon.
- Every two weeksA demo of working software
See the real product on staging, then agree the priorities for the next cycle together.
- Every milestoneDocumented acceptance
Each milestone closes against criteria set at the start, written down so there is nothing to argue about later.
Shared tooling for the whole project
FigmaGit & pull requestsA shared work boardZalo / SlackA dedicated staging environmentLiving documentationError tracking & analytics
Principles
Three principles throughout
01
Clear communication
One owner, one main channel, and plain language instead of jargon. You never have to guess where the project stands.
02
Evidence-based decisions
Every scope, design or technical choice comes with the reasoning, the alternatives considered and the trade-off, written down.
03
Quality from within
Performance, accessibility and maintainability are designed in from the start, not retrofitted once something breaks.
Commitments
What we commit to in writing.
A process is only trustworthy when it comes with real obligations. These sit in the contract, not in a sales conversation.
No vendor lock-in
We use widely adopted technology and document enough for another team to pick the work up.
Confidentiality
An NDA is signed before we touch business data. Access is granted at the minimum level and revoked at the end.
Transparent scope and cost
Every scope change is raised in writing first, with its impact on timeline and cost stated.
Post-launch warranty
Defects within the accepted scope are fixed during the warranty period agreed in the contract.
Honest about risk
If a request is not feasible or not worth doing yet, we say so up front instead of taking it on and dealing with it later.
FAQ
Common questions about the process
- How long does a project take?
- It depends on scope. We deliver in slices you can review and try, so you see results early rather than waiting until the end. The specific roadmap is agreed right after discovery.
- We already have designs or a development team — can we start mid-process?
- Yes. We review what you already have during discovery, then start from whichever stage fits. The one thing we always keep is agreeing scope and measures of success before going further.
- What happens if scope changes mid-project?
- Change is normal. New requests are recorded, re-estimated and raised in writing with their impact on timeline and cost. You decide to do it now, later, or not at all — before we start on it.
- How much of our time will this take?
- Most of it lands in the framing phase: roughly 2–3 sessions during discovery. After that, around 60 minutes every two weeks to review a demo and set priorities keeps the project on track.
- Are accessibility and performance actually tested?
- Yes. Both are reviewed during the verify stage, alongside functionality and content. Performance measurements before and after tuning come with the test report.
- Is there support after handover?
- Yes. The scope of maintenance and support is agreed based on what each project actually needs. The final stage of our process is launch & support, which includes a controlled release and operational handover.
Next step
Start with discovery.
One conversation to clarify goals and constraints. You leave with a scope proposal and a concrete roadmap.