Community

translate Automatic translation · View original

Have you ever discovered that you were building the right solution to the wrong problem?

Have you ever discovered that you were building the right solution to the wrong problem?
Few things hurt more in product than discovering, after weeks of flawless work, that the problem we were solving wasn't the one that mattered. There were no execution errors: the team delivered on time, with quality, exactly what was requested. And yet the result didn't move anything. The failure happened much earlier, at the moment we accepted a problem statement without questioning it.

The most expensive product mistake isn't technical

In agile culture we talk a lot about efficiency: delivering fast, iterating, reducing waste. But the most costly form of waste isn't building something slowly; it's building well something that didn't need to be built. And that happens when we accept a poorly framed problem.

Melissa Perri named it with an expression that has become a reference: the build trap, in Escaping the Build Trap (2018). Organizations fall into it when they measure their success by the number of features delivered rather than by the value generated. The team becomes a factory of outputs and loses sight of outcomes. The question "Are we building the right thing?" is replaced by "Are we building fast?"

The problem is that the trap doesn't feel like a trap. From the inside, everything seems to be going well: there's a backlog, there are sprints, there are deliveries. The machinery works. It's just aimed at the wrong target.

Why we accept poorly framed problems

If framing a problem badly is so costly, why do we do it so often? Thomas Wedell-Wedellsborg, in What's Your Problem? (2020), offers an explanation: we tend to fall in love with the first statement of the problem we receive and jump straight to generating solutions. His classic example is the building with a slow elevator. The obvious definition of the problem, "the elevator is slow," leads to expensive solutions: new motors, optimization algorithms. But reframing the problem as "waiting is annoying" opens up cheap and effective solutions, like installing mirrors on the landing. The problem was never the speed; it was the boredom of waiting.

There are several reasons why we accept the first framing without questioning it. The pressure to move forward penalizes reflective pauses: spending time interrogating the problem feels like "not producing." Hierarchy works against us: when the statement comes from above, questioning it feels like insubordination. And our own psychology betrays us: once we have a solution in mind, we reinterpret the problem so that it fits the solution, instead of the other way around.

Don Norman, in The Design of Everyday Things (2013), noted that expert designers resist the temptation to solve the problem presented to them and devote deliberate effort to determining what the real problem is. That resistance—not accepting the statement as it arrives—is one of the most underrated skills in product work.

Symptom, problem, and need: three different things

Many poorly framed problems arise from confusing three levels that are worth separating.

The symptom is what is observed: a metric that drops, a recurring complaint, a feature that's barely used. The problem is the interpretation of why the symptom occurs. The need is what the person is actually trying to achieve.

When a stakeholder says "we need an Export to Excel button," they are mixing all three levels into a single sentence that already comes with the solution built in. The work of product is to unpack it: what is the person requesting this actually trying to do? Maybe they need to share data with someone who doesn't have access to the system. Maybe they need a report the product doesn't offer. The export button may be the worst solution to a need we haven't even understood.

This is where the Jobs to Be Done framework is useful. The idea, popularized by Clayton Christensen and developed by Anthony Ulwick in Jobs to Be Done (2016), is that people "hire" products to do a job in their lives. If we don't understand the job, we optimize the wrong tool. Christensen's famous formulation—people don't want a drill, they want a hole, and in fact they don't even want the hole, but what the hole allows them to achieve—captures exactly this shift of focus.

Continuous discovery: questioning the problem before building

The practice that best protects against solving the wrong problem is separating discovery from delivery. Teresa Torres, in Continuous Discovery Habits (2021), proposes that product teams maintain regular contact with their users—ideally weekly—to keep alive the question of which problems deserve to be solved.

Her central tool, the opportunity solution tree, requires mapping opportunities—the real needs and pains detected—before jumping to solutions. This creates a discipline: no solution is justified on its own; each one must hang from a validated opportunity that, in turn, connects to a desired business outcome.

Marty Cagan, in Inspired (2017), distinguishes four major risks that discovery must address before committing building resources: value risk (will they want it?), usability risk (will they be able to use it?), feasibility risk (can we build it?), and business viability risk (does it work for the organization?). Building the right solution to the wrong problem is usually a failure of the first risk, value risk, disguised as execution success.

AI has made building cheaper and getting the problem wrong more expensive

Here a new tension appears, specific to our moment. Generative AI has drastically reduced the cost of building. What once required weeks of development can now be prototyped in hours. And while this is good news for speed, it aggravates an old risk.

When building was expensive and slow, the cost of construction itself imposed a certain caution: nobody wanted to invest three months without being reasonably sure. Now that building is cheap, that protective friction disappears. It's tempting to jump straight to generating the solution because it costs so little that it seems there's nothing to lose.

But there is something to lose. Every solution built—even a cheap one—generates maintenance, complexity, user expectations, and conceptual debt. A product full of features that solve the wrong problems isn't free just because it was cheap to build; it's a confusing, hard-to-maintain, misaligned product. AI reduces the cost of building, but it doesn't reduce—and may increase—the cost of building the wrong thing.

The conclusion is counterintuitive: the cheaper it becomes to build, the more valuable discovery becomes. The bottleneck is no longer execution capacity but the quality of the problem we choose to solve. In a world where anyone can generate a plausible solution in minutes, competitive advantage shifts toward whoever knows how to formulate the right problem. This is exactly the space where tools like ScrumIA, which integrate AI into the agile workflow without replacing the team's judgement, can help: accelerating the generation of hypotheses without exempting anyone from the responsibility of validating them.

Signs that you might be solving the wrong problem

It's worth keeping some warning indicators in mind. They are not conclusive proof, but they invite you to stop and think.

When no one on the team can clearly explain what will change in the user's life if this works, you're probably working on a solution, not a problem. When the problem statement already contains the solution ("we need an app," "we have to migrate to microservices"), someone skipped a step. When the justification for an initiative is "a major client asked for it" without understanding what that client was trying to achieve, there's a risk of confusing the request with the need. And when you've been building for weeks and still haven't spoken with a single real user, the risk is at its maximum.

None of these signs requires stopping. But all of them invite you to ask the question we so often skip: are we sure which problem we're solving and why it matters?

Reframing is not analysis to the point of paralysis

An honest nuance is needed here. Questioning the problem can degenerate into its own dysfunction: endless analysis, discovery that never ends, a team that reformulates the problem over and over without building anything. This is also waste.

The question is not choosing between building or questioning, but integrating both at a sustainable pace. Torres's continuous discovery is not an endless preliminary phase; it's a lightweight practice running in parallel with delivery. Reframing the problem doesn't mean freezing in the face of uncertainty, but reducing that uncertainty with the least possible effort before committing large resources. Sometimes the best way to validate a framing is to build a small, cheap experiment, not to debate in the abstract.

The balance lies in asking the right questions at the right moment, not in asking all of them, all the time.


Discovering that you built the right solution to the wrong problem is one of the most formative experiences in product, precisely because it doesn't feel like a mistake while it's happening. Everything seems to be going well until the result reveals that we were aiming at the wrong target.

The good news is that this skill—interrogating the problem before falling in love with the solution—can be cultivated. It requires discipline to resist the pressure to "get to work," humility to admit that the first framing may be wrong, and regular contact with the reality of users. In a moment when AI makes building almost anything trivial, this skill stops being a luxury of mature teams and becomes the difference between creating value and piling up useless features.

Take part in the poll

This article includes an active poll in the Scrum Manager community.

poll View the poll in the community