---
title: "How to Break Down a Problem: 6 Steps, 4 Worked Examples"
description: "How to break down a problem into small steps: a 6-step method worked on a school project, a party, a maths word problem and a program, with real code."
slug: how-to-break-down-a-problem
canonical: https://learn.modernagecoders.com/blog/how-to-break-down-a-problem/
date: 2026-11-15
dateModified: 2026-11-15
category: "Problem Solving"
tags: ["Problem Solving", "Decomposition", "Thinking Skills", "Python", "Students"]
keywords: ["how to break down a problem", "how to break down a complex problem", "how to break down a problem statement", "how to break down a math problem", "how to break down a problem into smaller parts", "decomposition examples", "problem decomposition"]
readTime: "17 min read"
author: "Modern Age Coders Team"
---
# How to Break Down a Problem: a 6-Step Method With 4 Worked Examples

> Big problems are not solved. Small ones are. Here is how to turn one into the other, on a school project, a birthday party, a word problem and a real program.

![How to break down a problem: one big goal at the top of a notebook page splitting into smaller and smaller tasks](/images/blog/how-to-break-down-a-problem/00-hero.png)

*By Modern Age Coders Team · 2026-11-15 · 17 min read*

**Quick answer:** To break down a problem, write the goal as one sentence with a clear finish line, split it into 3 to 5 parts that do not overlap, keep splitting each part until every piece starts with a verb you could do in the next ten minutes, put the pieces in order, solve and check one at a time, then join them and check the whole against the goal. It works the same way on a school project, a party, a maths word problem and a program.

To **break down a problem**, write the goal as one sentence that says what finished looks like, split it into three to five parts that do not overlap, and keep splitting each part until every piece is an action you could start in the next ten minutes. Then put the pieces in order, do and check them one at a time, and finally join them up and check the whole against the goal you wrote first.

That last step is the one most people skip, and it is why a project can feel ninety per cent done for a week. This guide works the method on four real tasks: a school science project, a child's birthday party, a maths word problem and a small program. Each one is broken down as a tree you can copy. The coding examples were run and the output under them is what they really printed.

If you want the wider problem solving method first, our guide to [how to improve problem solving skills](/blog/how-to-improve-problem-solving-skills) covers the full define, break down, try, check, improve loop. This page goes deep on the second step only, because it is where most people get stuck.

## Why breaking a problem down works

A big problem is hard for a simple reason: you cannot see the first move. "Make a science project" does not tell your hands what to do. "Write the question we are testing on one line" does. Breaking a problem down is the work of turning a goal you can describe into actions you can start.

It also makes problems checkable. You cannot easily check "the party went well". You can check "invitations sent by Friday" and "enough plates for 14 children". When every small piece has its own small check, the big result stops being a matter of luck.

Programmers call this **decomposition**, and it is one of the four parts of computational thinking. Our post on [computational thinking examples](/blog/computational-thinking-examples) shows it next to pattern recognition, abstraction and algorithms. Here we stay with decomposition and do it slowly.

## How to break down a problem in 6 steps

1. **Write the goal as one sentence with a finish line.** Not "do the project" but "a poster that answers one question with our own measurements, ready by Friday". If you cannot write this sentence, you do not understand the problem yet, and that is the real first task.
2. **Split it into 3 to 5 parts that do not overlap.** Ask: what has to be true for the goal to be met? Each answer is a part. Fewer than three usually means you have not split; more than six usually means you have mixed big parts with small ones.
3. **Keep splitting until every piece starts with a verb.** "Poster" is a topic. "Draw the results table" is an action. Stop splitting when a piece is small enough to start in the next ten minutes and finish in one sitting.
4. **Put the pieces in order.** Some pieces need others first (you cannot draw the results before you have them). Many do not, and those can be done in any order or by different people.
5. **Do one piece and check it.** Each small piece gets its own small test. Tick it off only when it passes.
6. **Join the pieces and check the whole.** Read the goal sentence again. Do the finished pieces really add up to it? This is where you find the gap nobody owned.

> **The ten-minute test**

> Point at any piece of your breakdown and ask: could I start this in the next ten minutes, without asking anyone what it means? If not, split it again. If you could do it in ten seconds, you have split too far, so join it back with its neighbour.

## Example 1: a school science project

Here is a real kind of task a Class 6 or Year 7 student gets: test a question and present it on a poster. Our student's question is "Does salt water freeze slower than plain water?"

**Step 1, the goal with a finish line:** a poster that answers the salt water question with our own measurements, and that I can explain to the class in two minutes, ready by Friday.

**Step 2, the parts:** what has to be true? We need a plan for the experiment, the experiment has to be run, the poster has to be made, and I have to be able to explain it. Four parts, no overlap.

**Step 3, split each part until it starts with a verb.** Instead of drawing the tree by hand, we wrote it as a small Python program. Only the leaves (the real actions) get a time estimate, and each bigger task is the total of the tasks under it. The program also flags any leaf that is still too big to do in one go.

```python
# A school project broken down as a tree. Only the leaves get a time
# estimate; every bigger task is just the sum of the tasks under it.
project = ("Science project: does salt water freeze slower?", [
    ("Plan the experiment", [
        ("Write the question and a guess", 15),
        ("List what to measure and how", 20),
    ]),
    ("Run the experiment", [
        ("Make 3 cups: plain, some salt, lots of salt", 15),
        ("Check the freezer every 30 minutes, note results", 60),
    ]),
    ("Make the poster", [
        ("Draw a results table and a bar chart", 40),
        ("Write what happened and why", 30),
        ("Glue, label, check spelling", 25),
    ]),
    ("Practise explaining it to the class", 20),
])

def show(node, depth=0):
    """Print the tree and return the total minutes under this node."""
    name, body = node
    if isinstance(body, int):          # a leaf: one small, doable action
        print("    " * depth + f"- {name} ({body} min)")
        return body
    print("    " * depth + f"+ {name}")
    total = sum(show(child, depth + 1) for child in body)
    print("    " * depth + f"  = {total} min for '{name}'")
    return total

def leaves(node):
    name, body = node
    if isinstance(body, int):
        return [(name, body)]
    return [leaf for child in body for leaf in leaves(child)]

total = show(project)
print()
too_big = [n for n, m in leaves(project) if m > 45]
print("leaves:", len(leaves(project)), "| total:", total, "min =", total // 60, "h", total % 60, "min")
print("leaves still too big to start (over 45 min):", too_big or "none")
```

Output:

```plaintext
+ Science project: does salt water freeze slower?
    + Plan the experiment
        - Write the question and a guess (15 min)
        - List what to measure and how (20 min)
      = 35 min for 'Plan the experiment'
    + Run the experiment
        - Make 3 cups: plain, some salt, lots of salt (15 min)
        - Check the freezer every 30 minutes, note results (60 min)
      = 75 min for 'Run the experiment'
    + Make the poster
        - Draw a results table and a bar chart (40 min)
        - Write what happened and why (30 min)
        - Glue, label, check spelling (25 min)
      = 95 min for 'Make the poster'
    - Practise explaining it to the class (20 min)
  = 225 min for 'Science project: does salt water freeze slower?'

leaves: 8 | total: 225 min = 3 h 45 min
leaves still too big to start (over 45 min): ['Check the freezer every 30 minutes, note results']
```

![A school science project broken down as a tree: the goal at the top splits into plan, run, poster and practise, and each splits into small timed actions adding up to 225 minutes](/images/blog/how-to-break-down-a-problem/01-project-tree.png)

*The goal splits into four parts, and each part into actions you can start today. Bigger boxes are just sums of the small ones.*

Three things this tree tells the student that the goal alone never did. The project is about three and three quarter hours of work, not "loads". The poster, not the experiment, is the biggest part, which surprises most students. And one leaf is flagged as too big: checking the freezer every 30 minutes for an hour. That one is fine to keep, because it is mostly waiting, but it tells you to start it early on a day you are at home. The program's flag did its job: it made you look.

**Step 4, the order:** plan before run, run before the results table. But "practise explaining" can start as soon as the plan exists, and the title and labels for the poster can be done while the water is in the freezer. Breaking it down shows you what can happen at the same time.

## Example 2: planning a birthday party

Real life is full of problems that are not homework. Say a parent is planning a party for an eight-year-old at home for 12 children on a Saturday afternoon. The goal with a finish line: *12 children have two happy hours, everyone gets home safely, and the house is back to normal by 7 pm.*

Notice what that sentence already did. "Back to normal by 7 pm" turned clearing up into a real part of the problem instead of an afterthought. Here is the breakdown:

| Part | Pieces (each starts with a verb) | Needs first |
| --- | --- | --- |
| Guests | Write the guest list with the child; send invitations; note allergies from replies | Date fixed |
| Food | Choose a simple menu that avoids every allergy; buy plates and cups; order or bake the cake | Allergy list |
| Games | Pick 3 games for 2 hours; make a playlist; set out prizes | Guest number |
| Space | Clear the living room; put breakable things away; set up a coat spot | Nothing |
| Ending | Write down who collects each child; pack small party bags; tidy with the family | Guest list |

The "Needs first" column is step 4 at work. It shows that the allergy replies block the menu, so the invitations have to go out early and must ask about allergies. Without breaking the party down, most people find this out on the Thursday before.

> **The gap nobody owned**

> When you join the parts back up (step 6), read the goal sentence again: "everyone gets home safely". No piece covered that until the Ending row was added. Joining up and re-reading the goal is how you catch the job that fell between two parts.

## How to break down a math problem

Word problems feel hard because all the information arrives in one paragraph. Breaking them down means pulling them apart into what you know, what you want, and the smaller questions in between. Here is one we wrote:

> **Our word problem**

> Riya's book has 420 pages. She reads 18 pages on a weekday and 30 pages on a Saturday or a Sunday. She starts on a Monday. On which day does she finish, and how many days does it take?

**Goal with a finish line:** a day of the week and a number of days, and a check that the pages add up to exactly 420.

**Break it into smaller questions:**

1. How many pages does she read in one full week? 5 weekdays times 18 is 90, plus 2 weekend days times 30 is 60, so 150 pages.
2. How many full weeks fit before the end? Two weeks is 300 pages, three weeks would be 450, which is too many. So two full weeks, 14 days, and 120 pages left.
3. How do the last 120 pages fall in week three? Monday to Friday is 5 times 18, which is 90, leaving 30. Saturday is a 30-page day, so she finishes on Saturday.
4. Count the days: 14 plus 6 (Monday to Saturday) is 20 days.

**Check:** 300 + 90 + 30 = 420. The same breakdown, written as three small functions in Python, gives the same answer:

```python
# Word problem: Riya's book has 420 pages. She reads 18 pages on a
# weekday and 30 pages on a Saturday or Sunday. She starts on a Monday.
# On which day does she finish, and on day number what?
DAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]

def pages_on(day_name):                  # sub-problem 1: one day's reading
    return 30 if day_name in ("Sat", "Sun") else 18

def pages_per_week():                    # sub-problem 2: one full week
    return sum(pages_on(d) for d in DAYS)

def finish_day(book):                    # sub-problem 3: walk day by day
    read, day = 0, 0
    while read < book:
        read += pages_on(DAYS[day % 7])
        day += 1
    return day, DAYS[(day - 1) % 7], read

print("pages in one week:", pages_per_week())
day, name, read = finish_day(420)
print("finishes on day", day, "which is a", name, "| pages read by then:", read)
```

Output:

```plaintext
pages in one week: 150
finishes on day 20 which is a Sat | pages read by then: 420
```

![A maths word problem broken into three smaller questions: pages in one week, full weeks before the end, and the last part of week three, joining to the answer Saturday, day 20](/images/blog/how-to-break-down-a-problem/02-word-problem.png)

*Three small questions instead of one big one. Each answer feeds the next.*

Each function is one of the smaller questions. That is not a coincidence: a well broken-down maths problem is already most of the way to a program. Our longer guide to [solving maths word problems](/blog/how-to-solve-maths-word-problems) has more of these, sorted by type.

## How to break down a problem statement in coding

In coding, the problem usually arrives as a statement: a paragraph, some examples, and a few limits. Before splitting the solution, split the statement itself into five boxes. Here is a short statement we wrote, broken down:

> **Our problem statement**

> A school's day starts at 08:30. Given a list of lesson lengths in minutes, print the time each lesson ends. Break times are counted as lessons. The day never runs past midnight.

| Box | What goes in it | From our statement |
| --- | --- | --- |
| Input | What you are given, and its form | A start time (08:30) and a list of whole numbers of minutes |
| Output | Exactly what to print, and its format | One end time per lesson, as HH:MM |
| Rules | Every condition the answer must obey | Breaks count as lessons; times carry over from 59 minutes to the next hour |
| Examples | Small cases you can work by hand | [40, 40] gives 09:10 then 09:50 |
| Edge cases | The awkward inputs the statement hints at | An empty list; a lesson that crosses an hour; the midnight limit (so no next-day case) |

Only now do you break the solution down: turn the start time into minutes since midnight, add each length in turn, turn minutes back into HH:MM, print. Four small jobs. The "Edge cases" box is where most wrong answers in tests come from, which is why it gets its own box rather than a thought at the end.

## How to break down a complex problem into a program

"Make a quiz game" is the kind of goal that leaves a beginner staring at an empty file. Broken down, it is four jobs: make answers comparable, mark one answer, run a whole round, and report the score. Each job is a function you can test on its own before you join them.

```python
# "Make a quiz game" is too big to start. Broken down, it is four small
# jobs, each one a function you can write and test on its own.
QUESTIONS = [
    ("7 x 8", "56"),
    ("Capital of Japan", "tokyo"),
    ("Number of sides on a hexagon", "6"),
]

def normalise(answer):                 # job 1: make answers comparable
    return answer.strip().lower()

def mark(question, given):             # job 2: mark one answer
    prompt, correct = question
    return normalise(given) == normalise(correct)

def play(questions, answers):          # job 3: run the whole round
    return [mark(q, a) for q, a in zip(questions, answers)]

def report(results):                   # job 4: tell the player how they did
    score = sum(results)
    return f"{score} out of {len(results)}"

# Test each job alone before joining them up.
print(normalise("  Tokyo "))           # expect: tokyo
print(mark(QUESTIONS[0], "56"))        # expect: True
print(mark(QUESTIONS[2], "six"))       # expect: False (a real gap!)
# Then the whole thing, with a pretend player's answers:
print(report(play(QUESTIONS, ["56", "TOKYO", "six"])))
```

Output:

```plaintext
tokyo
True
False
2 out of 3
```

Look at the third line of output. Testing the marking job alone showed that "six" is marked wrong when the answer is 6. Is that a bug? It depends on the goal, which is exactly the point: a small test on a small piece raised a question the whole game would have hidden. You decide (accept words for numbers, or tell players to type digits) and the decision goes back into the goal sentence.

This is how professional software is built too. A feature is broken into tasks small enough to finish in a day, each with its own test. Our page on [how to think like a programmer](/how-to-think-like-a-programmer) shows the same move at a larger scale.

## Common mistakes when breaking down a problem

- **Splitting by time instead of by part.** "First half, second half" is not a breakdown. Split by what has to be true.
- **Leaves that are still topics.** "Poster" or "food" cannot be started. Put a verb at the front and the vagueness shows.
- **Overlapping parts.** If two parts both include "buy decorations", either it gets done twice or each person thinks the other did it.
- **Splitting too far.** "Pick up the pen" is not a useful task. Stop at the ten-minute test.
- **No check on each piece.** A piece without a test is a hope, not a step.
- **Never joining back up.** The pieces can all be done and the goal still missed. Re-read the goal sentence at the end, every time.

## Breaking down problems for kids, teens and adults

| Age | A good problem to practise on | What the breakdown looks like |
| --- | --- | --- |
| 6 to 9 | Getting ready for school, building a Lego model, a simple Scratch game | Three to five picture steps, said out loud, in order |
| 10 to 13 | A school project, a word problem, a party plan | A written tree with verbs on every leaf and a tick box |
| 14 to 18 | Coursework, a coding assignment, exam revision | A tree with time estimates, an order, and a test for each piece |
| Adults | A work project, a house move, learning a new skill | Tasks small enough for one sitting, owners, and a final check against the goal |

For younger children, the best practice is out loud and physical. Ask "what do we need to do first?" while packing a school bag, and let them get the order wrong once. Our guide to [problem solving examples in real life](/blog/problem-solving-examples-in-real-life) has twelve more everyday problems to practise on.

## Why breaking problems down matters more when AI can write code

AI tools can now write a function if you ask for one clearly. That moves the valuable skill upstream. Someone still has to turn "make a quiz game" into four clear jobs, decide what "correct" means for "six", and check that the joined-up result meets the goal. A person who can break problems down gets good results from any tool. A person who cannot gets code that answers the wrong question.

> **AI tools have age rules**

> Check the vendor's age rule before a young learner uses any AI tool. Most chat assistants require users to be at least 13. ChatGPT's terms ask for a parent's or guardian's permission for anyone under 18, and Claude is for adults (18 and over) only. Under-13s should build these skills with puzzles, Scratch and Python, without a chatbot account. Our guide to [teaching kids AI at home](/blog/how-to-teach-kids-ai-at-home) covers safe options by age.

## How we teach it

The principles on our [how we teach](/how-we-teach) page are this method in a classroom: students explain their thinking out loud, we trace a loop line by line until they can predict every step, learners derive a rule themselves before they see it written down, we solve the same problem three ways, and mistakes are treated as data. You can see it in our [problem solving course for kids](/courses/problem-solving-and-computational-thinking-for-kids), the [problem solving and algorithms course for teens](/courses/problem-solving-dsa-masterclass-teens) and [Maths Through Coding](/courses/maths-through-coding), and our page on [teaching you how to think](/we-teach-you-how-to-think) explains why. The first class is free.

[Book a free class](/book-demo) [Book a priority demo](/book-demo)

## Frequently asked questions

**How do you break down a problem into smaller parts?**

Write the goal as one sentence with a finish line, split it into 3 to 5 parts that do not overlap by asking what has to be true, and keep splitting each part until every piece starts with a verb and could be started in the next ten minutes. Then order the pieces, check each one, and join them back up against the goal.

**How do you break down a complex problem?**

The same way as a simple one, with one extra step: write down which pieces depend on which. Complex problems are mostly complex because of their order and their dependencies, so a table with a "needs first" column turns a tangle into a sequence.

**How do you break down a problem statement in coding?**

Split the statement into five boxes before you write code: input, output, rules, examples and edge cases. Work one example by hand, then break the solution into small functions, each with its own test.

**How do you break down a math word problem?**

Write what you know, what you want, and the smaller questions that link them. Answer the small questions in order, each one feeding the next, and finish with a check that uses the original numbers, such as adding the parts back up to the total.

**What is it called when you break a problem into smaller parts?**

Decomposition. It is one of the four parts of computational thinking, along with pattern recognition, abstraction and algorithms.

**How small should the pieces be?**

Small enough that you could start one in the next ten minutes without asking what it means, and big enough that it is not a single trivial movement. One sitting per piece is a good rule.

**Why can I break a problem down but still not solve it?**

Usually because one piece is still too vague, or a piece has no check, so you do not know when it is done. Find the piece you keep avoiding and split it again. If you can follow solutions but not start your own, our post on [understanding solutions but not solving problems](/blog/why-can-i-understand-solutions-but-not-solve-problems) explains that gap.

**At what age can children learn to break down problems?**

From about 6, out loud and with real tasks such as packing a bag or building a model in steps. Written trees suit ages 10 and up, and time estimates and tests suit teenagers.

---

*Source: https://learn.modernagecoders.com/blog/how-to-break-down-a-problem/*
