Minimal illustration of an iceberg with a small tip above the waterline and a vast mass hidden below

Are We Solving the Right Problem?

The most expensive product mistakes often begin before anything is built—when we mistake the symptom for the problem.

James BagleyProduct Thinking6 min read

Most teams don’t struggle because they’re incapable of solving problems. They struggle because they decide too quickly what the problem is.

A request comes in. A symptom is visible. A stakeholder has a theory. The answer feels obvious enough, so the team accepts it and runs with it.

Maybe they need a dashboard. Maybe they need automation. Maybe they need a redesign. Maybe they need AI.

And sometimes they do.

But sometimes what looks obvious is only what’s easiest to see. That’s where costly mistakes begin.

The first answer isn’t always the right answer

There are plenty of reasons teams move quickly toward a solution. A deadline is tight and there’s pressure to show progress. The symptom is familiar, so the answer feels familiar too. A client or stakeholder walks in with a solution already in mind, and no one feels comfortable challenging it. Or everyone simply believes they understand the situation well enough already.

The trouble is that a single symptom can point to several different underlying problems. That makes product work a lot like diagnosis.

If someone has knee pain, the knee pain is the symptom. The problem might be tight hips. The root cause might be sitting for long stretches every day. Treat only the knee, and you may relieve the pain temporarily without ever addressing what’s creating it.

Teams do the same thing. A stakeholder says, “We need AI.” Maybe they do. But why? Is the real problem that people can’t find the information they need? A repetitive manual task? Slow decision-making? Too much time spent reviewing or summarizing information? An inefficient workflow? A lack of capacity?

Each of those problems could make AI feel like the obvious answer, but that doesn’t mean each of them needs it. Diagnose the symptom as the problem, and you can end up building the right solution for the wrong thing.

  1. Symptom

    What you see

  2. Problem

    What is actually happening

  3. Root cause

    Why it is happening

Look beneath the surface

Start with why

When someone tells me they need a particular solution, my first instinct isn’t to argue with it. It’s to understand it.

Why do you feel you need this? What’s driving the request? What’s happening today that isn’t working? Why is that a problem now? What changes if we solve it?

The goal isn’t to challenge the client, stakeholder, or team for the sake of being difficult. It’s to stay neutral long enough to see whether the evidence actually supports the original request.

That distinction matters. Good product thinking isn’t adversarial, it’s collaborative. You’re not there to prove someone wrong. You’re there to help the team understand the situation well enough to make a better decision.

Sometimes the evidence confirms the original idea. Sometimes it reshapes it. Sometimes it reveals that the request was only ever pointing toward the real problem. All three are useful outcomes.

Slow down to go faster

This kind of questioning can feel like unnecessary friction. When deadlines are tight, asking more questions can look like overthinking. When everyone already agrees on a direction, reopening the conversation can feel inefficient.

But sometimes you have to slow down to go faster.

The work done early saves you from compounded costs later. A wrong assumption doesn’t stay small once development begins. It becomes requirements, then designs, then technical decisions, then dependencies, then training, then process changes, then maintenance. The farther the wrong idea travels, the more expensive it becomes to unwind.

That’s why early clarity has so much leverage. A few difficult questions at the beginning can save months of work later.

A wrong assumption never stays small. It becomes requirements, designs, dependencies and process — long before anyone calls it a mistake.

Building the wrong thing well is still building the wrong thing

Teams can execute beautifully and still miss the mark. A polished dashboard doesn’t solve the wrong visibility problem. A well-designed workflow doesn’t fix a broken process if the real issue sits elsewhere. An intelligent AI feature doesn’t create value simply because the implementation is impressive.

Execution matters. But execution can’t compensate for poor diagnosis.

Building the wrong thing well is still building the wrong thing.

That’s why the work before the work matters so much. Not because we need certainty. We rarely get that. What we need is enough clarity to understand what we’re actually looking at.

Clarity is not certainty

Clarity doesn’t mean having all the answers. It means understanding the situation well enough to ask better questions.

And better questions change what becomes possible. They help us challenge assumptions without automatically rejecting them. They help us separate the visible symptom from the underlying problem. They help us recognize when a proposed solution is right, when it needs to change, and when we should be solving something else entirely.

The more clarity we gain, the better decisions we make. And better decisions create better outcomes.

So before moving too quickly toward the obvious answer, it’s worth stopping long enough to look beneath the surface. Challenge the thought. Challenge the idea. Challenge the solution. Not because it’s wrong, but because you don’t know yet.

What you uncover beneath the surface may change everything.

Don’t chase certainty.
Chase clarity.