Problem Solving
Structuring (1.3) tells you how a problem is built. Solving is the full loop that turns a messy situation into a chosen action — defining the right problem, decomposing it, betting on the parts that matter, generating real options, deciding, and iterating.
🎯 By the end you'll understand
A complete, repeatable problem-solving process; the difference between divergent and convergent thinking and when to use each; four durable heuristics (working backward, analogy, constraint relaxation, the five whys); and the traps — symptom-fixing, premature convergence, and confusing motion with progress.
KEY INSIGHTThe one idea to take away
Solving a problem is mostly the work you do before you start solving it — defining the right problem, then deciding which parts of it actually deserve your effort.
Smart people fail at problems not because they're bad at finding answers, but because they answer the wrong question, or pour effort into a part of the problem that doesn't move the outcome. A good solver spends a disproportionate amount of time up front — on definition and prioritization — and then moves fast and iterates. Problem solving is a pipeline, and the early stages set a ceiling on how good the later ones can be.
Effort spent solving is wasted unless it's pointed at the right problem (definition) and the part that matters (prioritization). Get those two wrong and the cleverest analysis in the world produces a beautifully optimized irrelevance.
DEFINITIONWhat problem solving actually is
A working definition: problem solving is the structured process of moving from an unsatisfactory current state to a desired state, through a chain of defining, decomposing, prioritizing, generating, deciding, and executing. Two things distinguish it from “just thinking hard”:
- It's a process, not a flash of insight. The flash of insight is real, but unreliable. A process gets you a usable answer even on the days the muse doesn't show up — and it makes your reasoning inspectable by other people, which matters the moment you work on a team.
- It separates phases that the mind wants to blur. The single biggest skill is keeping generating options separate from judging them, and keeping defining the problem separate from jumping to a solution. Untrained, we collapse all of this into one impatient lunge at the first answer.
This builds directly on Problem Structuring (1.3): before you solve, you must define. “Sales are down” is a symptom, not a problem. “Our trial-to-paid conversion fell from 9% to 5% after the April pricing change” is a problem you can actually attack. Definition is where most of the leverage hides.
FRAMEWORKThe six-step process
Here is the full loop. It's linear on paper and iterative in life — you'll loop back constantly — but the order matters, because each step constrains the next.
Define the right problem
State the gap between current and desired state precisely, and check you're solving the real problem, not a symptom or someone's preferred solution in disguise. (This is 1.3 doing its job.)
Structure & decompose
Break the problem into MECE sub-problems — an issue tree. A big vague problem becomes a set of smaller, answerable ones.
Prioritize
Not all sub-problems matter equally. Use the Pareto principle: find the ~20% of branches that drive ~80% of the outcome, and ignore the rest for now.
Generate & analyze solutions
For the branches that matter, diverge — produce many candidate solutions — then converge — analyze and narrow. Keep these two modes apart.
Decide
Choose under uncertainty: weigh options against criteria, account for risk and reversibility, and commit. The mechanics of this are Decision-Making (1.5).
Execute & iterate
Ship the smallest version that tests your bet, observe what reality says, and loop back — often all the way to step 1, because acting teaches you what the problem really was.
Beginners treat steps 1–5 as a waterfall that ends in a perfect answer. Operators treat the whole thing as a loop: a fast first pass to a defensible bet, then iteration. You learn more about the problem from one real attempt than from a week of planning.
CORE CONCEPTDiverge then converge — and never at once
The engine of step 4 is a deliberate alternation between two opposite mental modes:
- Divergent thinking — generating many options, broadening, association, “yes-and.” Quantity over quality. Judgment is suspended on purpose. This is where novel solutions come from.
- Convergent thinking — evaluating, comparing, filtering, killing weak ideas. Quality over quantity. Judgment is the whole job. This is where you commit.
Both are essential. The failure mode is running them simultaneously — judging ideas the moment they appear. Criticism in the divergent phase strangles the half-formed option that would have become the best one. So the discipline is to fence them off in time: first generate freely with no evaluation, then switch and evaluate hard. A useful tell that you're stuck in the wrong mode: if you find yourself saying “yes, but…” to every new idea, you've converged too soon; if you've listed twenty options and can't choose, you've forgotten to converge at all. The skill is knowing which gear you're in and when to shift.
The best-known divergent technique is brainstorming — and it deserves an honest word. The original rules (defer judgment, go for volume, build on others' ideas, welcome wild ones) are sound. But the research is unkind to the group version: studies repeatedly find that the same people, brainstorming alone and then pooling their ideas (“brainwriting”), generate more and better ideas than a group shouting over each other. Group brainstorming suffers from production blocking (only one person talks at a time), social loafing, and evaluation apprehension — and it slides into groupthink, where the desire for harmony quietly converges the room before any real diverging happened. Brainstorm individually first; converge together.
SEE ITThe solving pipeline
Watch a real, messy situation move through the pipeline — from a vague complaint to a chosen, testable bet. Step through it and see how each stage narrows the chaos into a plan.
Notice what happened: the input was a vague feeling (“churn is too high”) and the output was a single, narrow, testable action. Nothing magical occurred — the pipeline just refused to let you skip from complaint straight to a random fix. Each stage forced a question the previous stage couldn't answer.
CORE CONCEPTFour heuristics that earn their keep
Beyond the process, a handful of moves reliably unstick hard problems. These aren't algorithms — they're heuristics, rules of thumb that work often enough to be worth reaching for.
Working backward
Start from the goal state and ask “what must be true immediately before this?”, then chain back to where you are. Powerful when the goal is clear but the path isn't — proofs, project plans, “what would have to be true for us to hit $1M ARR?”
Analogical problem solving
Map your problem onto one you (or another field) already solved. “How does nature / logistics / a different industry handle this distribution problem?” The risk is a surface match that hides a structural mismatch — test that the analogy holds where it matters.
Constraint relaxation
Temporarily delete a constraint you've been treating as fixed — budget, headcount, the existing architecture, “we've always done it this way.” Solve the easier problem, then ask which relaxations were actually negotiable. Often the binding constraint was self-imposed.
The “five whys” (preview)
Ask “why?” repeatedly to walk from symptom toward cause: slow page → big query → no index → schema never reviewed → no review process. You'll study this properly in Root-Cause Analysis (1.8); here it's the antidote to fixing symptoms.
The five whys can dead-end at a convenient scapegoat; analogy can mislead; working backward fails if the goal itself is wrong. Use them to generate candidate moves, then subject the candidates to the convergent, critical scrutiny from Lesson 1.1.
EXAMPLEEnd to end: a SaaS retention problem
Let's run the full loop on one realistic problem, the way you'd actually do it.
1 · Define. The complaint arrives as “our churn is too high — we need to make customers love us more.” Notice the embedded solution (“make them love us”). We resist it and define the gap precisely: monthly logo churn is 6%, up from 3.5% last year; the increase is concentrated in customers who signed up in the last 90 days. Now we have a problem, not a mood. (And a quiet win: we've narrowed scope to new customers.)
2 · Decompose. An issue tree: a customer churns because (a) they never reached first value (onboarding), (b) they got value but the price stopped justifying it, (c) a competitor pulled them, or (d) their own need disappeared. MECE-ish branches, each checkable.
3 · Prioritize. We pull the data. 70% of the early churners never completed the core setup step — branch (a). Pareto says: ignore pricing and competitors for now; the onboarding branch is where the outcome lives. We've just refused to spend three weeks on a pricing study that wouldn't have moved the number.
4 · Generate, then analyze. Diverge first, no judging: guided setup wizard, white-glove onboarding calls, an in-app checklist, removing the setup step entirely, a “starter template,” an email drip, a progress bar, an AI setup assistant, a money-back trigger if setup isn't done in 7 days. Then converge: score them on impact × effort. The wizard and the starter template are high-impact, low-effort; white-glove calls don't scale; “remove the step” is impossible because it's load-bearing.
5 · Decide. Two strong candidates, limited engineering. We choose the starter template first — it's the smallest change that directly attacks “never reached first value,” and it's reversible. (The full decision criteria — reversibility, expected value, risk — are Lesson 1.5.)
6 · Execute & iterate. We ship the template to half of new signups as an experiment. Two weeks later: setup-completion among the test group jumps from 30% to 55%, and their early churn drops. The bet paid — partially. We loop back: completion is up but still not 90%, so we re-enter the loop on the remaining gap. We now have evidence that the onboarding branch was the right one, and a sharper sub-problem — why does roughly half the test group still stall? — to attack next. Acting taught us the problem better than planning could have.
We never let the embedded solution (“make them love us”) survive step 1; we let data, not opinion, pick the branch in step 3; we generated widely before judging in step 4; and we shipped a small reversible test instead of a grand rollout. None of those moves is clever. All of them are disciplined.
WEAKNESSWhere problem solving goes wrong
The page is slow, so you add a cache — and the slow query underneath keeps rotting. Symptom fixes feel productive and buy a little time, then the problem returns wearing a new mask. If you haven't walked from symptom to cause (the five whys, and properly in 1.8), assume you're treating a symptom.
Premature convergence: the first plausible solution arrives, feels like relief, and quietly ends the search. You then spend your effort polishing a mediocre option instead of finding a better one. Force a real divergent phase — “what are three other ways?” — before you let yourself fall in love with any of them.
Meetings, dashboards, refactors, busy Slack threads — motion that feels like solving but doesn't change the metric you defined in step 1. Worse, once you've sunk months in, the sunk-cost trap keeps you executing a failing plan because quitting feels like waste. The cost is already gone; the only question is whether the next hour is better spent here or elsewhere.
KEY INSIGHTWhere this connects in your course
- Critical thinking (1.1) — the scrutiny you apply during the convergent phase, when you're killing weak options and pressure-testing your favorite.
- Problem structuring (1.3) — steps 1–2 of this loop done well: defining the right problem and decomposing it into MECE sub-problems before you solve anything.
- Decision-making (1.5) — step 5 in depth: choosing among the options you generated, under uncertainty, with criteria and reversibility in mind.
- Root-cause analysis (1.8) — the cure for symptom-fixing: the five whys and friends, so step 1 attacks causes rather than appearances.
- Hypothesis-driven thinking (1.9) — a faster engine for steps 3–6: lead with a sharp hypothesis, then gather only the evidence that would confirm or kill it.
Problem solving is the spine of this stage. Structuring sets it up, critical thinking sharpens it, decision-making closes it, and root-cause and hypothesis thinking make it fast and honest. Everything in the later stages — persuading, negotiating, leading — is, underneath, a problem being solved with people involved.
GLOSSARYKey terms introduced
- Problem solving
- The structured process of moving from an unsatisfactory current state to a desired one — define, decompose, prioritize, generate, decide, execute, iterate.
- Divergent thinking
- Generating many options with judgment suspended; quantity over quality.
- Convergent thinking
- Evaluating, comparing, and narrowing options to commit; quality over quantity.
- Brainstorming
- A divergent technique (defer judgment, seek volume, build on ideas). More effective done individually then pooled than as a live group.
- Working backward
- Reasoning from the goal state toward the present by asking what must be true just before each step.
- Premature convergence
- Settling on the first plausible solution and ending the search before better options surface.
- Iteration
- Looping back through the process after acting, using what reality revealed to redefine or re-solve the problem.
ACTIVE RECALLCheck your understanding
Answer in your own words first, then reveal.
1Why do the early steps (define, prioritize) matter more than being clever at generating answers?›
They set a ceiling on the rest. A brilliant solution to the wrong problem, or to a sub-problem that doesn't move the outcome, is wasted effort. Definition and prioritization point your cleverness at something that matters.
2What's the difference between divergent and convergent thinking, and why keep them apart in time?›
Divergent generates many options with judgment suspended; convergent evaluates and narrows. Running them at once — judging ideas as they appear — kills half-formed options that would have become the best ones. Generate freely first, then switch and evaluate hard.
3What's the honest case against group brainstorming?›
The rules are sound, but groups underperform: only one person talks at a time (production blocking), some coast (social loafing), people self-censor (evaluation apprehension), and the room drifts toward harmony (groupthink). The same people brainstorming alone and then pooling ideas usually do better.
4You've spent three months on a plan that isn't working. How should sunk cost factor into whether to continue?›
It shouldn't. The three months are gone regardless. The only relevant question is whether the next increment of effort is better spent continuing or switching — judged on future expected value, not on honoring past investment.