I like to watch someone use a product before anyone argues about colors. Where do they hesitate? Where do they give up? That tells me more than a long feature list, and it's far cheaper to learn before the expensive part starts.

The scenarios below are hypothetical examples illustrating our approach. They do not describe client engagements or measured results.

Watch real people first. Design for the job they're doing. Prove it before you polish it.

Good design isn't decoration. It's what makes a product easy enough that people keep using it, and that starts with watching them, not with picking colors.

  • Start with people. Who they are, what they're trying to get done, and where they get stuck today.
  • Test cheaply. Sketches and clickable mockups before anything is built.
  • Let evidence decide. What people do counts for more than what anyone in the room assumes.
  • Keep it simple. Every extra button is something else to learn, build and maintain.

Three examples

Testing an idea before building it

The short version: Test the idea with real people before paying to build it.

A company that trains restaurant staff wants a learning app. Leadership is excited and ready to fund a full build. Nobody has checked whether busy managers would actually use it, or what they'd use it for.

What we'd do

  1. Talk to the people who'd use it. Short conversations with managers and staff about how training really happens today.
  2. Sketch the core idea. A clickable mockup of just three screens, made in days, not months.
  3. Watch five people try it. Small tests reveal most of the confusing parts before a line of code exists.
  4. Check real interest. A simple page describing the app, to see whether people sign up for early access.

How we'd know it worked

  • Managers can explain in their own words why they'd use it
  • Testers complete the main task without help
  • Enough sign-ups to justify building a first version

The catch: A few weeks of testing feels slower than diving in. It's far cheaper than building the wrong app.

What the business gets: A go, no-go or change-course decision based on evidence, before the big money is spent.

Fixing the screen where customers give up

A quote form in five steps; at the third step people used to drop away, and now a smoother step carries them through.
Fix the step where people give up before redesigning everything.

The short version: Fix the step where people give up before redesigning everything.

An online insurance quote form gets plenty of visitors, but few finish it. The first instinct is a complete redesign. A redesign is expensive and might not touch the real reason people leave.

What we'd do

  1. Find where people drop off. The analytics show most leave at one step: a long page of questions.
  2. Watch them struggle. Usability sessions reveal confusing wording and questions people can't answer without paperwork.
  3. Fix the biggest snag first. Plain words, fewer questions up front, and a way to save and come back later.
  4. Compare old and new. With enough visitors, half see the old form and half the new one, so the result is clear.

How we'd know it worked

  • More people finish the form with the new version
  • No drop in quote accuracy
  • Support questions about the form go down

The catch: Small, targeted fixes look less impressive than a shiny redesign. They're quicker, cheaper and easier to measure.

What the business gets: More finished quotes from the same visitors, without rebuilding what already works.

A roadmap and a design system for a growing product

A road with a few marked milestones toward the horizon, beside a tidy grid of matching interface parts.
Say no to most requests, so the product stays easy to use.

The short version: Say no to most requests, so the product stays easy to use.

A software product has grown fast. Every customer request becomes a feature, and each new screen looks a little different. The product is getting harder to use and slower to build, and the team can't say what matters most next.

What we'd do

  1. Sort the requests. Group feature requests by the problem behind them and how many customers share it.
  2. Build a simple roadmap. Now, next and later, tied to business goals, and reviewed every quarter.
  3. Create a design system. A shared kit of buttons, forms and layouts, so new screens look and behave the same.
  4. Measure what changes. Product analytics show whether new features get used, and feed the next roadmap review.

How we'd know it worked

  • Every roadmap item linked to a goal and real customer demand
  • New screens built from the shared kit
  • Unused features reviewed, and removed if they're not earning their place

The catch: Saying no, or not yet, to some customers is uncomfortable. A focused product serves most of them better.

What the business gets: A product that stays easy to use as it grows, and a team that builds what matters.

The short of it

Design decisions are business decisions. We make them with real people, small tests and clear goals, before the expensive part starts.

However the work starts, we prefer a clearly scoped project: defined deliverables, a practical budget, documentation and a proper handover, so your team can run what we build without needing us.

This is the thinking behind PreciseMP's Product Strategy & UX/UI service.

Related reading: How to Scope an MVP: Prove One Thing First and Build or Buy? When Custom Software Makes Sense.