Microsoft Visio: Turning a Manual Process into a Clear Flowchart

Turn a manual process that lives in someone’s head into a Visio flowchart that anyone can follow, check, and correct.

Most teams have at least one process that only one person really understands. It runs fine until that person is out, or until a client asks how it works and there is nothing to hand them. A written runbook helps, but a list of steps hides the decisions and the rework loops that make the process what it is. A flowchart shows all of it at once.

This post walks through how to build a proper flowchart in Microsoft Visio, using a generic data pipeline as the example. If your diagram needs to span multiple systems or roles, pair this with the companion post on swimlanes, layers, and shape data.

A note on versions: Microsoft updates these apps constantly, and the exact wording, button placement and menu options can differ between versions, update channels and license types (perpetual vs Microsoft 365). If something on your screen does not match exactly what you see here, the feature is almost always still there, just in a slightly different spot or under a slightly different name. Use this guide as a map, not a pixel-perfect match.

Step 1: Write the process as plain steps first

Before you open Visio, get the process out of your head and into a plain list. Do not worry about shapes yet. Write one action per line, in the order it happens, and mark every point where you stop to check something.

Here is our example process, a batch load that has always been run by hand:

1. Load the incoming batch into the warehouse.
2. Verify the loaded record count matches the source count.
3. Apply manual corrections from the corrections table onto the main table.
4. Run the QA validation queries.
5. Run the flag procedures that bucket records by period.
6. Run the summary and aggregation jobs.
7. Reconcile the summary, fact, and warehouse tables.
8. Generate the final output.

Notice steps 2, 4, and 7 are checks, not actions. Those become decision points. Everything else is a straight action. Getting this separation right on paper is most of the work.

Step 2: Know the four shapes you actually need

Visio ships with dozens of stencils, but a clear flowchart usually needs only four shapes. Open Visio, go to File, New, choose the Flowchart category, and select Basic Flowchart. The Shapes panel on the left gives you these:

Terminator (rounded rectangle): the single Start and the single End. Every flowchart has exactly one of each.
Process (rectangle): one action. “Load the batch” or “Run the summary jobs.”
Decision (diamond): one yes or no question. “Do the counts match?”
Subprocess (rectangle with side bars): a step that is really its own defined routine, like a stored procedure or a scheduled job. Use this when a box hides more detail you may document separately.

Four shapes cover almost everything. Resist the urge to add more shape types, since variety makes a diagram harder to read, not easier.

Step 3: Lay out the actions in order

Drag a Terminator onto the page and label it “Start.” Below it, drag a Process shape for the first action.

To connect them, hover over the bottom of the Start shape until you see a colored arrow, then drag to the next shape. Visio draws a dynamic connector that stays attached even when you move the shapes later. This is the key habit: always connect shape to shape, never draw a loose line that only looks connected.

Keep a single direction, either top to bottom or left to right, and stick with it for the whole diagram. Label each action with a verb first: “Load batch,” “Apply corrections,” “Run QA queries.” Short and active reads faster than a full sentence.

Use the Subprocess shape for steps 5 and 6 in our example, since the flag procedures and the summary jobs are defined routines that live somewhere else. That signals to the reader that a box has more behind it without dumping that detail into this view.

Step 4: Add the decision points and the rework loops

This is where a flowchart earns its keep. A plain list pretends every run goes perfectly. A real process has checks that sometimes fail and send you back a step.

For each check, drop a Decision diamond and phrase it as a yes or no question:

After “Load batch,” add a diamond: Do the counts match?
After “Apply corrections,” add a diamond: Did the QA queries pass?
After the summary jobs, add a diamond: Do the tables reconcile?

Label both branches leaving every diamond. This is the step people skip most, and an unlabeled branch is guesswork. A finished version looks like this:

For a failure that loops back, draw the connector from the fix step to the shape it should retry. The QA branch above returns to the QA check so the reader sees that you rerun the check, not the whole pipeline. Those loops are the part that only lived in someone’s head before.

Step 5: Make it readable

A correct flowchart that is hard to read still fails its job. A few Visio habits fix most of it:

Select everything, then use Home, Position, Auto Align & Space to line shapes up and even out the gaps.
Keep connectors from crossing where you can. If two lines must cross, Visio adds a small line jump so the reader can tell they do not connect.
Size every box of the same type the same way. Matching sizes read as “same kind of thing.”
Give the page a title block with the process name, the owner, and the date. A diagram with no owner and no date goes stale silently.

If the process crosses systems or teams, move each stage into its own swimlane so the reader sees who or what owns each step. The swimlanes post covers that, along with Shape Data, which lets you attach details to a box, such as the script name or table a step touches, without cluttering the picture.

Step 6: Validate it against reality

The last step is a walkthrough. Trace the diagram out loud against a real run, or hand it to someone who runs the process and ask them to follow it start to finish. Every place they hesitate is a missing box or an unlabeled branch. Fix those, and the flowchart becomes the source of truth instead of the person.

That is the real goal. Not a pretty picture, but a diagram accurate enough that a new person could run the process from it, and honest enough that anyone can spot where it could go wrong.

The short version

Write the steps as plain text first, and mark which ones are checks.
Use four shapes: Terminator, Process, Decision, Subprocess.
Connect shape to shape so lines stay attached.
Add a decision diamond for every check, and label both branches.
Draw the rework loops back to the right step.
Align, title, and then walk it through against a real run.

For the next level, containers, swimlanes, layers, and shape data, see Microsoft Visio Intermediate: Swimlanes, Layers, and Shape Data.