Problem First
What is being solved, before what it looks like.
Product Design Services
Product Design Services From Problem to Shipped Feature
Design that ends at a handoff file is a set of pictures. Product design services cover the whole path: understanding the problem, designing the response, supporting the build through the decisions that come up during it, and measuring whether the thing worked after it shipped.
We Stay Involved Through the Build
Most of what determines how a feature turns out is decided after the design was handed over.
Present During Build
Because questions arise that the file does not answer.
States Specified
Loading, empty and error included rather than assumed.
Measured After
Whether it worked, not whether it shipped.
Scope Questioned
Including whether the feature should exist.
What product design is evaluated on
Product design is judged on whether the thing being built solves a problem someone has, which is a different question from whether it is well made. These checks cover the problem as much as the execution.
Problem evidenceWhat indicates the problem exists outside the team’s assumption
Current behaviourWhat people do today instead, including workarounds
Primary userWho this optimises for when needs conflict
Success definitionWhat observable change indicates this worked
Scope boundaryWhat this deliberately does not address
Adoption pathHow an existing user discovers and starts using it
Migration costWhat existing users must change to move to it
Failure and edge statesWhat happens when the assumptions do not hold
Technical feasibilityWhether the approach can be built within real constraints
Measurement in placeWhether the instrumentation exists before launch, not after
Instrumentation before launch is the row most often deferred and least recoverable. A feature released without measurement cannot be evaluated afterwards, because the baseline no longer exists — which means the decision about whether to invest further gets made on impression.
Product Design, Explained
What Does It Cover?
Four stages, and the last two are where most design engagements stop.
Discuss Your Product →- 1
Understanding
The problem, the users and the constraints.
- 2
Designing
Flows, screens and states.
- 3
Building
Present for the decisions the file did not cover.
- 4
Measuring
Whether the shipped thing solved the problem.
What Product Design Covers
End to end, including the parts after the design file.
For an existing product, UX audit is usually the better starting point. For an existing product, a UX audit is usually the better starting point; the build alongside it is web application development.
How We Work on Product
Understand, design, build alongside, measure. The last two are where the difference is.
Define the Problem
Including whether it is worth solving.
Research Enough
To design against evidence rather than assumption.
Design and Test
Flows, screens and states, validated where uncertain.
Support the Build
Present for the questions that arise.
Measure
After release, against the original problem.
What stage the product is at
The design problem changes completely depending on whether the product exists, whether it has users, and whether those users are the ones it was built for.
Products still finding their audience
Where the central uncertainty is who this is for and what they need. Design work here should be cheap and disposable, because most of it exists to learn something rather than to ship. Building carefully before the question is settled is the expensive mistake.
Products with users and unclear direction
Where people are paying and the roadmap is a list of requests. The work is establishing what the product is for well enough to decline things, which is as much UX strategy as it is design.
Adding a significant new capability
Where something substantial is being added to an existing product and the risk is that it fits badly. Navigation, permissions and mental model all have to absorb it, and those are usually harder than the feature itself.
Products serving two divergent audiences
Where the product has grown to serve groups with conflicting needs and each release compromises both. This needs an explicit decision about primacy before any design work will help.
Rebuilding a product that works
Where the existing product has real users and the temptation is a clean start. The most valuable work is usually cataloguing what the current version does that nobody documented, because those are the behaviours users will miss.
Handoff
Why the Handoff Model Loses So Much
A design file cannot answer every question the build raises, and someone answers them anyway.
What gets decided during the build?
What happens when a list is empty, what the error says, how the layout behaves at an unanticipated width, what occurs if the data takes four seconds.
None of that is usually in the file. Each gets decided by a developer with a deadline, sensibly and inconsistently, and the shipped product differs from the design in dozens of small ways.
A designer available during implementation resolves those in minutes each. The alternative is discovering them in a review after release, when changing them costs a ticket and a sprint.
Why does measuring after change the work?
Because a design judged on shipping is judged on whether it looks right. A design judged on outcome has to be honest about whether the problem was solved.
Sometimes it was not, and the useful response is to say so and revise — which does not happen when the engagement ended at handoff.
It also improves the next decision, because the team accumulates evidence about what worked rather than a portfolio of features that were delivered on time.
Most product failures are problem failures
Products fail more often because they solved something nobody urgently needed than because the interface was poor. A well-designed answer to a weak problem performs worse than an adequate answer to an acute one, and no amount of design refinement changes that.
The evidence that a problem is real is behavioural rather than stated. People already spending time on a workaround, paying for something inadequate, or maintaining a spreadsheet to compensate are demonstrating the problem exists. People agreeing in an interview that something sounds useful are not.
This is why product design work should begin with what people do today rather than what they say they want. The workarounds are the specification — each one marks a need strong enough that someone built their own solution to it.
Designing the adoption, not just the feature
A new capability in an existing product has a problem a new product does not: existing users have working habits and no reason to change them. Features are routinely built, released and then used by a small fraction of the people they were built for, because nothing connected them to the moment the user needed it.
Adoption has to be designed alongside the feature. That means deciding how an existing user encounters it — ideally at the point where their current approach becomes painful, rather than through an announcement they will not read. It also means being honest about migration cost: a feature requiring people to abandon a working process needs to be substantially better, not marginally.
The measurement that matters here is not usage in the first week, which is inflated by curiosity, but whether people who tried it are still using it a month later. That distinction is only available if the instrumentation was in place before launch.
Knowing what to leave out
Every product accumulates capability, because adding is easier than removing and each addition is individually defensible. The cumulative result is a product that does many things adequately and nothing obviously well, which is harder to sell and harder to use than a narrower one.
Deciding what not to build is the part of product design with the least visible output and the most effect. It requires a stated position on who the product is for and what it optimises for, so requests can be assessed against something rather than accepted on the strength of who asked.
Removing capability is harder still, because someone always depends on it. Usage data makes the conversation possible — a feature used by a very small number of accounts is a candidate, and knowing exactly who they are turns a general debate into a manageable migration.
Questions, answered.
Product design services cover the full path from problem definition through research, design, build support and post-release measurement — rather than ending at a handoff file.
Because a design file cannot answer every question implementation raises — empty lists, error text, unanticipated widths, slow data. Those get decided by someone regardless; better with the designer present.
You find out, which is the point of measuring after release. A design judged on shipping is judged on appearance; one judged on outcome has to be honest about whether the problem was solved.
Usually, yes. Product design works best embedded alongside engineering rather than delivering to it, because that is where the decisions that shape the result actually happen.
For an existing product, usually a UX audit — it establishes where the problems are before design effort is committed to any of them.
Because a design file cannot answer every question implementation raises — empty lists, error text, unanticipated widths. Those get answered by someone regardless; better with the designer present than as forty small unchosen differences.
Product design includes deciding what to build and why; UI/UX design covers how it works and looks once that is settled. In practice the boundary varies by organisation. What matters is that someone owns the problem question — a team that only owns execution will build well-designed answers to problems nobody validated.
Enough to resolve the expensive uncertainties, which are usually structural rather than visual. Whether the flow makes sense, whether the model matches how users think, and whether the approach is buildable are worth settling first. Detail that can be adjusted after release does not need resolving beforehand.
Evidence that people are already working around its absence is the strongest available signal — a spreadsheet, a manual process, a competitor being used alongside you. Requests are weaker evidence, because customers describe solutions and the underlying need is often different from what they asked for.
Cautiously. Large customers ask for things specific to how they operate, and a product shaped entirely by one account becomes bespoke software with a subscription model. The useful test is whether the underlying need is shared by others, which is a different question from whether the requested solution is.
Against outcomes named before the work started — whether the problem it targeted has reduced, whether the intended users adopted it, whether it is still used after the novelty. Measuring after release without a baseline gives numbers with nothing to compare them to, which is why instrumentation belongs in the design rather than after it.
Still deciding if product design services is right for you?
Talk to UsThe File Did Not Say What the Error Says
A design handoff contains the screens: populated, working, at the widths that were drawn. It is thorough, annotated, and covers what was asked for.
Implementation then raises forty questions it does not answer. What appears when the list is empty. What the error text says. What happens at a width nobody drew. What the user sees while four seconds pass.
Each gets answered by a developer under deadline, reasonably and inconsistently — and the shipped product differs from the design in forty small ways that nobody chose and nobody can now afford to revisit.
Free Product Conversation
Talk Through What You Are Building
Tell us what problem you are solving and where you are in the process. We will tell you what would actually help at this stage.
Claim Your Free Marketing Audit
Enhance Your Brand Potential At No Cost!
- Expect a response within 24 hours
- NDA available upon request
- Dedicated product specialists