How to Plan an Algorithm With a Flowchart (KS3 Computing)

To plan an algorithm with a flowchart, use five standard shapes — oval, rectangle, parallelogram, diamond, and arrow — to map out each step and every decision before you write a single line of code. KS3 students who master flowcharts find both algorithm design and debugging significantly easier.

Why use a flowchart to plan an algorithm?

A flowchart is a visual representation of an algorithm. Writing code first and planning later is one of the most common mistakes novice programmers make. A flowchart forces you to think through the logic — especially decision branches and loops — before syntax errors distract you.

The DfE national curriculum for computing (gov.uk/government/publications/national-curriculum-in-england-computing-programmes-of-study) requires KS3 students to "use two or more programming languages, at least one of which is textual, to solve a variety of computational problems" and to understand abstraction and decomposition. Flowcharts are the standard tool for the planning stage.

The five standard flowchart shapes

Every flowchart at KS3 (and at GCSE) uses the same set of symbols. Using the correct shape matters: GCSE mark schemes award marks for correct symbol use.

Step-by-step: how to draw a flowchart for an algorithm

Step 1 — State the problem clearly

Before picking up a pencil, write one sentence describing what the algorithm must do. Example: "The algorithm should ask the user for a number and tell them whether it is even or odd."

A clear problem statement prevents the flowchart from growing in unexpected directions.

Step 2 — Identify the inputs and outputs

• Input: a whole number entered by the user.
• Output: the message "Even" or "Odd."

Inputs and outputs always appear in parallelograms.

Step 3 — List the steps in plain English

Write out what must happen before you draw anything:

1. Start.
2. Ask the user to enter a number.
3. Check whether the number is divisible by 2 (remainder is 0).
4. If yes, display "Even."
5. If no, display "Odd."
6. Stop.

Step 4 — Draw the flowchart

Use the five shapes to translate your list. Here is a text representation of how the even/odd flowchart looks:

[OVAL: Start]
      |
[PARALLELOGRAM: Input number from user]
      |
[DIAMOND: Is number mod 2 = 0?]
    /   \
  YES    NO
  |       |
[PARA:  [PARA:
Output  Output
"Even"] "Odd"]
  |       |
   \     /
    \   /
[OVAL: Stop]

The diamond is the most important shape. Every diamond must have exactly two exits labelled Yes and No (or True and False). If a diamond has more than two exits, you need to break the decision into smaller questions.

Step 5 — Trace through the flowchart with test data

Before writing any code, walk through the flowchart manually with at least two test values — one that should produce "Even" and one that should produce "Odd."

Test 1 — Input: 8

• Is 8 mod 2 = 0? Yes → output "Even". Correct.

Test 2 — Input: 7

• Is 7 mod 2 = 0? No → output "Odd". Correct.

Test 3 — Input: 0

• Is 0 mod 2 = 0? Yes → output "Even". Correct (zero is even by convention).

If a test produces the wrong output, the error is in the flowchart logic — find and fix it now, before translating to code.

Step 6 — Translate the flowchart into code

Once every test passes in the flowchart, the code almost writes itself. In Python:

number = int(input("Enter a number: "))
if number % 2 == 0:
    print("Even")
else:
    print("Odd")

Notice how the if / else structure directly mirrors the diamond in the flowchart. This is the whole point: the flowchart did the thinking; the code is just the translation.

How to represent a loop in a flowchart

Many algorithms repeat steps. In a flowchart, a loop is shown by drawing an arrow that goes backwards (upwards) from a later step to an earlier one, creating a cycle. The loop always needs a decision diamond with a "Yes, keep looping" path and a "No, exit the loop" path.

Worked example — counting from 1 to 5:

[OVAL: Start]
      |
[PROCESS: Set counter to 1]
      |
[DIAMOND: Is counter > 5?]
    /   \
  YES    NO
  |       |
[OVAL:  [PARA: Output counter]
 Stop]    |
        [PROCESS: Add 1 to counter]
          |
          |___back up to the DIAMOND

The arrow from "Add 1 to counter" loops back up to the diamond. Each time the counter increases, the condition is re-checked. When counter reaches 6 (greater than 5), the "Yes" branch fires and the algorithm stops.

Common flowchart mistakes to avoid

• Missing the Start/Stop ovals — always include both; GCSE mark schemes penalise their absence.
• Decision diamonds with more than two exits — a diamond tests one yes/no condition. If you need three outcomes, use two diamonds in sequence.
• Arrows without direction — every arrow must clearly show which way the flow moves. If two arrows cross, add a bridge (a small bump on one line).
• Combining process and decision in one shape — "Add 1 to counter AND check if done" must be two shapes, not one.
• Not labelling Yes/No on diamond exits — unlabelled branches lose marks and cause confusion when the flowchart is shared.

How flowcharts lead into pseudocode

Flowcharts and pseudocode are complementary. Flowcharts are better for visualising loops and decisions (especially when explaining to someone else). Pseudocode is better for expressing precise logic line by line, closer to real code. Many KS3 schemes of work use both: draw the flowchart first, write pseudocode second, then code third. Either way, the algorithm is correct before programming begins.

BBC Bitesize (bbc.co.uk/bitesize/guides/z4bv4wx/revision/1) provides interactive flowchart exercises alongside their KS3 computer science materials — a useful next step after this guide.

Frequently asked questions

What shapes are used in a flowchart in KS3 computing?

KS3 uses five standard shapes: oval (terminal — Start/Stop), rectangle (process — an action), parallelogram (input/output), diamond (decision — a yes/no question), and arrows (flow lines). Using the correct shape for each element is assessed at GCSE.

How do I show a loop in a flowchart?

Draw an arrow that points backwards from a later step to an earlier one, forming a cycle. Include a decision diamond in the loop with a condition that eventually breaks the cycle. Label the Yes branch (continue looping) and the No branch (exit the loop) clearly.

What is the difference between a flowchart and pseudocode?

A flowchart is a visual diagram showing the flow of an algorithm using shapes and arrows. Pseudocode is structured English text describing the algorithm step by step, closer in style to real code. Both represent the same algorithm; flowcharts are better for visualising branches and loops, while pseudocode is easier to translate directly into a programming language.

Can a flowchart have more than one decision diamond?

Yes. Complex algorithms often need several diamonds, either in sequence (one after another) or nested (one inside a branch of another). Each diamond must still have exactly two exits — Yes and No.

Why do computing teachers ask students to flowchart before coding?

Flowcharting forces students to solve the logic problem first, before syntax rules become a distraction. Fixing an error in a flowchart takes seconds; finding the same error buried in Python code can take much longer. It is also easier to spot infinite loops and missing conditions in a visual diagram than in lines of text.

For Socratic computing tutoring — from algorithms and flowcharts to Python — see aitutors.me.