Tagthose

Three steps to a signed scope.

Start with step one

No discovery invoice before you know we are a fit. The first call is free.

Getting to a scope.

Initial consultation

Fifteen minutes on your product vision, your market and the users you are trying to serve. We ask a lot of questions and resist the urge to pitch.

You bring: the problem, any analytics you have, and whoever can make decisions.
You leave with: an outside read on your product and a sense of whether we are useful to you.

A roadmap written for your project

We send back a detailed scope: phases, deliverables, timelines, pricing and what we need from your side to hit the dates. You read it, you push back, we revise.

Turnaround: two to five working days after the call.
Commitment: none until you sign. Nothing starts before that.

The team starts building

Research, design, engineering and testing run against the agreed roadmap. Work is visible continuously rather than revealed at a milestone, so there are no reveal-day surprises in either direction.

Cadence: a weekly call plus a shared working file you can open any day.

Six phases, and what actually comes out of each.

Not every project runs all six. The scope says which ones yours includes, and what you receive at the end of each.

Discover

Stakeholder workshops, user interviews, competitor review and a teardown of your existing analytics. We are looking for the gap between what the business thinks is happening and what users actually do.

Deliverables: research findings, personas, journey maps, prioritised problem list.

Define

We agree the design principles for this specific product and restructure the information architecture around user intent. This is the phase that prevents six rounds of revision later.

Deliverables: design principles, sitemap, information architecture, success metrics.

Structure

Wireframes and flows before any visual design. Structure before skin — it is far cheaper to discover a broken flow in grey boxes than in finished screens.

Deliverables: annotated wireframes, user flows, clickable low-fidelity prototype.

Design

Visual design and the component system underneath it — including the empty, error, loading and permission states that decide whether a product feels finished.

Deliverables: production screens, design system, prototypes, brand assets.

Build

Front-end engineering, running in parallel with late-stage design rather than after it. Performance budgets and accessibility targets are set before the first commit, not audited in a panic before launch.

Deliverables: deployed responsive code, documentation, QA across devices and assistive tech.

Validate

Usability testing with real users, split tests on the decisions worth arguing about, and an iteration sprint against the results. Launch is the midpoint, not the finish line.

Deliverables: test findings, session recordings, ranked fix list, implemented changes.

How we work

Four things we will not negotiate on.

These exist because every one of them has, at some point, been the thing that saved a project.

One decision-maker

We need a single person who can approve work. Design by committee does not produce a worse result slowly — it produces a worse result expensively.

Access to your users

Five conversations with real users will beat fifty internal opinions. If we cannot reach your users, we will say so before we start rather than guess.

Research before pixels

We will not open a design file on day one. Even a compressed week of research changes what gets built, and the week pays for itself.

We say when we disagree

If we think a requested feature will hurt your users, you will hear it with reasoning attached. You are still the client, and it is still your call.

Step one costs nothing.

Book a free review

Fifteen minutes with a senior designer