How to Map and Improve Your Small Business Processes

We tried writing our processes down once. We put them in a shared Google Doc, and for a while it worked.

Then everything ended up in there. Notes, half-finished checklists, ideas for later. The doc got so crowded that nobody wanted to scroll through it, so we stopped opening it. The process was written down, but we kept doing things from memory. And from memory, we usually didn’t do them the right way.

That’s the trap with most process documentation in a small business. Writing a process down is easy. Getting anyone to look at it again is the hard part. A map only helps if it’s short and clear, and if it lives where the work actually happens.

This guide covers business process mapping for small business owners and small teams. You’ll learn how to map one process, how to spot the steps that slow you down, and how to keep the map from turning into another dump document. I’ll use one of our own processes as the example: how we publish a post on this blog.

What is business process mapping?

Business process mapping means drawing how one piece of work moves through your business, from the thing that starts it to the thing that finishes it. A good map shows each step, who does it, where decisions happen, and where work sits waiting.

The most common kind of process map is a flowchart. The American Society for Quality lists a handful of basic shapes, and you only need four of them to start:

• Rectangle: a step (“Send the quote”)
• Diamond: a yes/no decision (“Did they approve it?”)
• D-shape: a delay or wait (“Waiting on the supplier”)
• Parallelogram: something coming in or going out (“Signed contract”)

If more than one person touches the work, give each person or role their own row. That’s called a swimlane diagram. The Agency for Healthcare Research and Quality recommends this layout when you want to see the handoffs between people, which is usually where things go wrong.

There’s also a formal standard called BPMN, used by large companies and software teams. You don’t need it. A small business gets almost all the value from boxes, arrows and names.

How to map a business process in 6 steps

You can do this with sticky notes on a wall, index cards on a table, or an app. The tool matters a lot less than being honest about what really happens.

1. Pick one process that causes pain. Choose something you do at least every week and that goes wrong often enough to annoy you. Good first picks: sending a quote, onboarding a new client, handling a refund, reordering supplies. Don’t try to map the whole business. One process is plenty.
2. Set the start and the finish line. Write down what kicks the process off and what “done” looks like. For a quote, that might be “customer asks for a price” and “customer says yes or no.” Without clear edges, maps keep growing until nobody can read them.
3. List the steps as they happen today. Not how they’re supposed to happen. If someone always texts the owner before sending an invoice, that text is a step. Use one card per step and start each with a verb: “Check stock,” “Email the invoice.”
4. Put a name on every step. Who actually does it? If the answer is “whoever’s around,” write that down. It’s one of the most useful things a map can tell you. With more than one person involved, sort the cards into swimlanes.
5. Mark the decisions and the waits. Add a diamond wherever the work splits (“In stock?”). Then mark every spot where work sits waiting on someone or something. In a lot of processes, the waiting takes longer than the work itself.
6. Walk through it with the people who do the work. Both ASQ and AHRQ say the same thing: check the map with the people involved. They’ll catch the workaround you didn’t know about. That’s usually the most important card on the board.

Keep the finished map small enough to fit on one screen. If a single step needs its own ten steps, give it a separate map and link to it. It’s the same idea we use to turn a big goal into a step-by-step plan.

Process map example: how we publish a blog post

Here’s a real process from Flowboard. Every post on this blog goes through the same eight steps:

1. Pick a topic and check what already ranks for it.
2. Draft the post in a shared doc.
3. Make the thumbnail image.
4. Add the post to the site, including its page and its link from the blog.
5. Add it to the sitemap so search engines can find it.
6. Set the SEO title and description.
7. Build and test the site, then save a restore point.
8. Publish, then ask Google to index the new page.

Written as a list, that looks tidy. Laid out as a map, with each step showing which tool it happens in, something else stood out. The problems we’d run into all showed up at handoffs, where the post moved from one tool to the next.

Three of them, specifically:

• Doc to site: our drafting tool quietly drops short internal links like “/pricing”. The post looked fine in the draft and lost its links on the way over.
• Image to site: big images sent the wrong way got cut off partway through, with no error to warn us.
• SEO settings: saving the title for a new post could reset older posts back to automatic titles. Nothing looked broken on the new page. The damage was on the old ones.

None of these were hard to fix once we could see them. Drafts now use full web addresses, which get shortened only when the post goes on the site. Images are made directly on the server. And we added a check between steps 7 and 8: before anything goes live, we confirm the links work, the image loads all the way, and the older posts still have their titles.

That check is the real improvement. Publishing now waits until it passes. The rest of the process stayed exactly the same.

How to improve business processes once they’re mapped

A map by itself doesn’t fix anything. It just makes problems easy to point at. Once yours is done, go through it card by card and look for five things:

• Waits. Where does work sit untouched? A quote that waits two days for the owner to glance at it is a two-day delay, even if the glance takes a minute.
• Handoffs. Every time work changes hands or changes tools, something can fall through. Our blog example had three problems, and all three were at handoffs.
• Loops. Arrows that point backward mean rework. If invoices often go back for corrections, find the step that keeps sending them back.
• Orphan steps. A step with no clear owner is a step that sometimes doesn’t happen.
• Habit steps. Ask “what would break if we skipped this?” for every card. Sometimes the honest answer is nothing.

Then pick one fix. Most fixes are one of these:

1. Cut it. Remove a step that doesn’t change the result.
2. Combine it. Merge two steps the same person does back to back.
3. Reorder it. Start steps at the same time when they don’t depend on each other.
4. Give it an owner. Put one name on every step, not “the team.”
5. Add a check. Put a gate right before the spot where things keep breaking, so work can’t move on until the check passes.

Change one thing at a time. Run the new version a few times before judging it. Then update the map so it matches what you do now. If you want proof it helped, track one simple number before and after, like how many days a quote takes or how many invoices get redone.

Common process mapping mistakes

Mapping the ideal instead of the real. If the map shows how things should work, it’ll look great and teach you nothing. The workarounds are where the problems are hiding.

Turning the map into a dump document. This is the one that got us. Our Google Doc started as a process and slowly became a place for everything else too. Keep the map to steps, owners, decisions and waits. Put notes, how-to’s and files next to the step they belong to, not in one long pile.

Adding too much detail. If you need a legend to read it, it’s too much. A map for a team of three should take about a minute to understand.

Mapping alone. The owner’s version of a process is rarely the same as the version the person doing it every day would draw.

Making it once and filing it away. A map nobody opens goes stale fast. Keep it where the work happens, and update it whenever something breaks or a step changes. Five minutes of upkeep beats a full rewrite a year later.

Trying to fix everything at once. Change five steps together and you won’t know which change helped. Go one at a time.

Doing it in Flowboard

A map is only useful if you keep coming back to it, and that’s what we designed Flowboard around. Here’s how we’d map and improve a process in it:

• Lay the steps out on one canvas, each with an owner and a status, using flowchart symbols and swimlanes when you need them (visual project planning).
• Add a gate before the spot that keeps breaking, so the next step waits until the check is done (gates).
• Attach the how-to to the step it belongs to, so notes stay next to the work instead of piling up in one doc (project documents).
• Give big steps their own sub-board, so the main map stays readable (sub-boards).

If you’d like to try it on one of your own processes, there’s a 7-day free trial.