What Is a Flowchart? Symbols, Rules, and Examples

In the previous article, we learned about algorithms and how they describe a solution step by step.

But sometimes a written list of steps is not enough. When a problem becomes slightly more complicated, it can be useful to represent the solution visually.

This is where flowcharts become useful.

A flowchart allows us to represent the steps of a problem using symbols, arrows, decisions, and processes.

Instead of reading a long list of instructions, you can look at a flowchart and understand how the solution moves from one step to another.

What Is a Flowchart?

A flowchart is a graphical representation of an algorithm or process.

In simple words:

A flowchart is a diagram that represents the steps of a process or solution using standard symbols and arrows.

For example, a simple program can be represented as:

Start
  ↓
Input Data
  ↓
Process Data
  ↓
Display Result
  ↓
Stop

Each step can be represented using a particular flowchart symbol.

Why Are Flowcharts Used?

Flowcharts are useful because they make the logic of a problem easier to visualize.

They can help you:

Understand a problem
Visualize the solution
Plan a program before coding
Identify decisions
Understand repeated processes
Explain logic to others
Find possible logical errors
Document a process

For beginners, flowcharts are particularly useful because they provide a visual connection between a problem, an algorithm, and a program.

Algorithm vs Flowchart

An algorithm and a flowchart can describe the same solution, but they use different forms.

Algorithm

Uses written steps.

1. Start
2. Enter two numbers
3. Add the numbers
4. Display the result
5. Stop

Flowchart

Uses graphical symbols.

   Start
     ↓
Input Numbers
     ↓
 Add Numbers
     ↓
Display Result
     ↓
    Stop

So we can think of it as:

Problem
   ↓
Algorithm
   ↓
Flowchart
   ↓
Program

Not every programmer must create both an algorithm and a flowchart for every program, but both are useful ways of thinking about a solution.

Basic Flowchart Symbols

Flowcharts use standard symbols for different types of operations.

The most commonly used symbols are:

Symbol	Name	Purpose
Oval	Terminator	Start or Stop
Rectangle	Process	Calculation or processing
Parallelogram	Input/Output	Input or output
Diamond	Decision	Condition or decision
Arrow	Flow line	Shows direction
Circle	Connector	Connects different parts

Let's understand each one.

1. Terminator Symbol

The terminator is generally represented by an oval or rounded shape.

It is used for:

Start
Stop
Beginning
Ending

Example:

   ___________
  /           \
 |   START     |
  \___________/

A simple program usually begins with Start and ends with Stop.

2. Process Symbol

A rectangle represents a process or operation.

It can represent:

Calculation
Assignment
Processing
Data manipulation

For example:

+-------------------+
| Calculate Total   |
+-------------------+

Suppose:

Total = A + B

This can be represented as a process.

3. Input/Output Symbol

A parallelogram is generally used to represent input and output.

For example:

   /------------------/
  /  Enter Number    /
 /------------------/

It can represent:

Input:
Enter number

Output:
Display result

4. Decision Symbol

A diamond represents a decision or condition.

For example:

       /\
      /  \
     / A? \
    /  >B? \
    \      /
     \    /
      \  /
       \/

A decision normally has different possible paths.

For example:

Is number even?
      /     \
    Yes      No
     ↓        ↓
   Even      Odd

The decision symbol is especially important when creating flowcharts for conditional statements.

5. Flow Line

An arrow or flow line shows the direction in which the process moves.

For example:

Start
  ↓
Input
  ↓
Process
  ↓
Output
  ↓
Stop

The arrows tell us what happens next.

6. Connector

Connectors are used when a flowchart becomes large or when connecting different parts of a diagram is more convenient.

They help avoid unnecessarily long or crossing flow lines.

For small beginner programs, connectors are usually not necessary.

Basic Structure of a Flowchart

A simple flowchart can follow this structure:

        START
          ↓
        INPUT
          ↓
       PROCESS
          ↓
        OUTPUT
          ↓
         STOP

This is closely related to the Input → Processing → Output model.

Example 1: Adding Two Numbers

Let's create a flowchart for:

Write a program to add two numbers.

Algorithm

1. Start
2. Input A
3. Input B
4. Calculate Sum = A + B
5. Display Sum
6. Stop

Flowchart

        START
          ↓
     Input A, B
          ↓
   Sum = A + B
          ↓
    Display Sum
          ↓
         STOP

The input is represented using an input/output symbol, the addition is a process, and the beginning and ending are represented by terminators.

Example 2: Check Whether a Number Is Even or Odd

Problem:

Check whether a number is even or odd.

Algorithm

1. Start
2. Input number
3. Calculate number % 2
4. If remainder is 0
      Display Even
   Otherwise
      Display Odd
5. Stop

Flowchart

          START
            ↓
      Input Number
            ↓
     Is number % 2 = 0?
          /       \
       Yes         No
        ↓           ↓
      Even         Odd
        \           /
         \         /
          ↓       ↓
            STOP

The important part here is the decision.

The diamond asks a question:

Is the remainder equal to 0?

There are two possible paths:

Yes → Even
No → Odd

Example 3: Find the Largest of Two Numbers

Problem:

Find the largest of two numbers.

Algorithm

1. Start
2. Input A and B
3. Check whether A > B
4. If yes, display A
5. Otherwise, display B
6. Stop

Flowchart

          START
            ↓
        Input A, B
            ↓
          A > B?
         /     \
       Yes      No
        ↓        ↓
    Display A  Display B
        \        /
         \      /
           STOP

This flowchart clearly shows how a decision creates two possible paths.

Example 4: Calculate the Area of a Rectangle

Problem:

Calculate the area of a rectangle.

Formula:

Area = Length × Width

Flowchart

          START
            ↓
    Input Length, Width
            ↓
 Area = Length × Width
            ↓
      Display Area
            ↓
           STOP

There is no decision in this problem, so the flowchart follows a simple sequence.

Example 5: Check Pass or Fail

Suppose a student passes if the percentage is at least 40%.

Algorithm

1. Start
2. Input percentage
3. Check percentage >= 40
4. If yes, display Pass
5. Otherwise, display Fail
6. Stop

Flowchart

           START
             ↓
      Input Percentage
             ↓
       Percentage >= 40?
          /         \
        Yes          No
         ↓            ↓
       PASS          FAIL
          \          /
           \        /
             ↓
            STOP

Again, the diamond represents the condition.

Example 6: Multiplication Table

A flowchart can also represent repetition.

Suppose we want to print the multiplication table of a number from 1 to 10.

A simplified flowchart is:

          START
            ↓
         Input N
            ↓
        Set i = 1
            ↓
          i <= 10?
         /       \
       Yes        No
        ↓          ↓
   N × i           STOP
      ↓
  Display Result
      ↓
   i = i + 1
      ↓
   Back to
   condition

This shows an important concept: the flow can move backward when a process needs to be repeated.

Later, this will connect directly with Python loops such as for and while.

Flowcharts and Decision Making

One of the most important uses of flowcharts is representing decisions.

Suppose we have:

if marks >= 40:
    Pass
else:
    Fail

The flowchart represents this visually:

          Marks
            ↓
       Marks >= 40?
         /       \
       Yes        No
        ↓          ↓
      Pass        Fail

This makes the logic easier to see.

Flowcharts and Loops

Flowcharts can also represent repeated operations.

For example:

        START
          ↓
       i = 1
          ↓
       i <= 5?
       /     \
     Yes      No
      ↓        ↓
    Print i   STOP
      ↓
   i = i + 1
      |
      └──────────→ back to condition

The arrow returning to the condition represents repetition.

Rules for Drawing a Flowchart

When creating a flowchart, follow some basic rules.

Rule 1: Start with Start

The flowchart should normally have a clear starting point.

Rule 2: End with Stop

A completed process should have a clear ending point.

Rule 3: Use arrows

Arrows should show the direction of the process.

Rule 4: Use appropriate symbols

For example:

Rectangle → Process
Diamond → Decision
Parallelogram → Input/Output
Oval → Start/Stop

Rule 5: Keep the flow clear

Avoid unnecessary crossing lines.

Rule 6: Keep the steps logical

The flowchart should represent the actual order in which operations happen.

Advantages of Flowcharts

Flowcharts have several advantages.

Easy to understand

A visual diagram can be easier to understand than a long written explanation.

Helps in planning

You can design the logic before writing code.

Helps find logical errors

Incorrect paths or missing decisions can sometimes be spotted easily.

Useful for communication

A flowchart can help explain a program to someone who does not know the programming language.

Useful for documentation

Flowcharts can document how a process works.

Helps beginners

Students can understand program flow visually before learning complex programming syntax.

Limitations of Flowcharts

Flowcharts are useful, but they are not perfect for every situation.

1. Large programs can create large flowcharts

A complicated application may require a very large diagram.

2. Updating can take time

If the logic changes significantly, the flowchart may need to be redesigned.

3. Complex software may require other diagrams

Large software systems often use additional design and modeling techniques.

For simple programming problems, however, flowcharts can be very helpful.

Flowchart vs Algorithm vs Program

These three concepts are connected.

Concept	Purpose
Problem	Describes what needs to be solved
Algorithm	Describes the solution step by step
Flowchart	Represents the solution visually
Program	Implements the solution using code

A typical process is:

Problem
   ↓
Understand
   ↓
Break into Parts
   ↓
Algorithm
   ↓
Flowchart
   ↓
Python Program
   ↓
Testing

You do not always need every stage for every small program, but learning these concepts helps develop structured problem-solving skills.

Flowcharts in Real-World Applications

Flowcharts are not limited to programming exercises.

They can be used to represent:

Business processes
Banking procedures
Admission systems
Order processing
Login systems
Customer support processes
Manufacturing processes
Software workflows
Decision-making systems

For example, a simple login process could be:

       START
         ↓
    Enter Username
         ↓
      Enter Password
         ↓
    Credentials Valid?
       /          \
     Yes           No
      ↓             ↓
    Login       Show Error
      ↓             |
     STOP ←─────────┘

This makes the process easy to visualize.

Flowcharts in AI Projects

Flowcharts can also help organize AI projects.

For example, a simple image classification system could be represented as:

        START
          ↓
     Upload Image
          ↓
    Preprocess Image
          ↓
    AI Model Analysis
          ↓
    Generate Prediction
          ↓
     Display Result
          ↓
         STOP

A real AI system can be much more complicated, but flowcharts can help developers understand the overall workflow.

How to Create a Flowchart for a Programming Problem

Use this simple method:

Step 1: Understand the problem

Know exactly what needs to be solved.

Step 2: Identify the input

Determine what information the user or system provides.

Step 3: Identify processing

Determine what calculations or operations are required.

Step 4: Identify decisions

Look for conditions such as:

Is the number greater than 10?
Is the student passed?
Is the password correct?

Step 5: Identify output

Determine what result needs to be displayed or produced.

Step 6: Connect the steps

Use arrows to show the flow.

Step 7: Test the flowchart

Follow the arrows using sample values and check whether the result is correct.

A Simple Flowchart Checklist

Before considering your flowchart complete, check:

Does it have a clear start?
Does it have a clear end?
Are the input steps included?
Are all required processes included?
Are decisions represented correctly?
Are arrows pointing in the correct direction?
Are the symbols appropriate?
Can another person understand the logic?
Does the flowchart produce the expected result for sample inputs?

Key Takeaways

A flowchart is a graphical representation of a process or algorithm.
Flowcharts use standard symbols to represent different operations.
An oval generally represents Start or Stop.
A rectangle represents a process.
A parallelogram represents input or output.
A diamond represents a decision.
Arrows show the direction of the process.
Flowcharts are useful for understanding and planning programs.
They can represent sequences, decisions, and loops.
Flowcharts can be used in programming as well as many real-world processes.
They can help beginners understand program logic before writing Python code.

Frequently Asked Questions