Process Documentation Template in Markdown (Free)

November 11, 2026 · 14 min read

Process Documentation Template: Map Any Workflow in Markdown

A process documentation template gives every recurring workflow the same shape: an owner, a trigger, ordered steps, a flow map and a plan for when things go wrong. Below you'll find a copy-and-paste Markdown version with the map drawn as a Mermaid flowchart, plus one fully filled-in example.

What Does Process Documentation Mean?

Process documentation is a written record of how a recurring workflow runs, from the event that triggers it to the outcome that ends it. It names the person responsible for each step, shows where the path splits, and says what to do with the cases that don't fit.

It differs from an SOP, which pins down one fixed routine in strict, compliance-style detail. A process doc is wider: it covers handoffs between roles and teams, and it usually carries a diagram. Keeping it in Markdown means the text, the diagram and the change log all live in one plain-text file. If a single fixed routine is what you need, use our SOP template instead.

The Process Documentation Template (Copy and Paste)

This template for process documentation is plain Markdown, so it works in any editor, wiki or repository that reads .md files. Copy the block below into a new file and replace each placeholder in angle brackets. The process map sits inside the file as a Mermaid code fence, so the outer block uses four backticks to keep it intact.

# Process: <name>

| Field | Value |
|---|---|
| Owner | <role and name> |
| Trigger | <the event that starts this process> |
| Start and end | <first action> to <final outcome> |
| Inputs | <what you need before step 1> |
| Tools and systems | <apps, forms or accounts the steps use> |
| Outputs | <what exists when it's done> |
| Last reviewed | <YYYY-MM-DD> |
| Next review | <YYYY-MM-DD> |

## Purpose and scope

<Why this process exists, in one or two sentences.>
In scope: <cases it covers>. Out of scope: <cases it doesn't, and where they go>.

## Roles

| Role | Responsible for |
|---|---|
| <role> | <steps or decisions they own> |

## Process map

```mermaid
flowchart TD
    A([Trigger]) --> B[First step]
    B --> C{Decision?}
    C -->|Yes| D[Next step]
    C -->|No| E[Other branch]
    D --> F([End state])
    E --> F
```

## Steps

1. **<Role>:** <Verb-first action>.
2. **<Role>:** <Check something>. If <condition>, go to step 3. Otherwise go to step 4.

## Decision points

| Decision | If yes | If no | Map node |
|---|---|---|---|
| <question> | Step <n> | Step <n> | C |

## Exceptions

| Trigger | What to do | Who decides |
|---|---|---|
| <unusual case> | <action> | <role> |

## Related documents

- <policy, form or upstream process this one depends on>

## Change log

| Date | Change | By |
|---|---|---|
| <YYYY-MM-DD> | First version | <name> |

Each section answers a question a new team member would otherwise ask out loud:

  • The metadata table says who to ask and whether the doc is still trusted. A past "Next review" date is an instant warning sign.
  • The Trigger and Start and end rows stop scope creep. If a step happens before the trigger, it belongs to a different process.
  • Roles turn "someone checks the order" into a named job, which is where most handoffs fail.
  • Decision points and Exceptions cover the branches that the happy path hides.
  • Change log records why the process changed, not just that it did.

If you also need README, changelog or meeting-notes files, our Markdown templates collection has ten of them. None of those covers process docs, which is why this one exists.

Draw the Process Map as a Mermaid Flowchart

A Mermaid flowchart turns a few lines of text into a diagram, and GitHub, GitLab and our editor all render it from a fenced code block tagged mermaid. A process map only needs five pieces of the syntax:

  • flowchart TD draws the chart top-down. Use LR for left to right.
  • A[Log ticket] is a step. A([Customer asks]) gives a rounded stadium shape, which reads well for start and end.
  • B{Within 30 days?} makes a diamond for a decision.
  • --> connects two nodes, and -->|Yes| labels the connection.
  • subgraph groups nodes, which you can use as simple swimlanes per role.

All five are documented on the Mermaid flowchart syntax page. Put together, they draw the refund process from the filled-in example further down, with every decision and the escalation path visible at a glance. You'll find its source in that example's Process map section.

To show who owns which box, wrap the nodes in subgraphs. An id followed by a bracketed title, such as subgraph lead [Team lead], gives the group a short id and a readable label:

```mermaid
flowchart LR
    subgraph agent [Support agent]
        B[Log ticket] --> C{Within 30 days?}
    end
    subgraph lead [Team lead]
        E[Review request]
    end
    C -->|No| E
```

For other diagram types and more node shapes, see our guide to Mermaid diagrams in Markdown. To tweak a map on its own and export it as PNG or SVG, paste it into the Mermaid editor. If your organisation needs formal notation with pools, events and gateways, that's what BPMN 2.0.2, the Object Management Group standard, is for.

A Filled-In Workflow Documentation Template Example

Here's the same workflow documentation template with every section filled in for a customer refund request. Note how each decision in the steps points to a step number and matches a diamond on the map.

# Process: Customer refund request

| Field | Value |
|---|---|
| Owner | Support lead |
| Trigger | A customer asks for a refund by email, chat or the help form |
| Start and end | From ticket logged to ticket closed, with the customer notified |
| Inputs | Order number, order date, payment method, reason |
| Tools and systems | Help desk queue, payment provider dashboard |
| Outputs | Refund issued or declined, customer told why, ticket closed |
| Last reviewed | 2026-11-02 |
| Next review | 2027-05-01 |

## Purpose and scope

Decide every refund within 2 business days and apply the same rules to everyone.
In scope: web store orders paid by card or PayPal. Out of scope: wholesale invoices (see Wholesale credit notes).

## Roles

| Role | Responsible for |
|---|---|
| Support agent | Steps 1 to 4 and 6, refunds under 200 USD |
| Team lead | Step 5, orders over 30 days old or 200 USD and up |
| Finance | Chargebacks and disputed payments |

## Process map

```mermaid
flowchart TD
    A([Customer asks for a refund]) --> B[Agent logs ticket]
    B --> C{Order within 30 days?}
    C -->|Yes| D{Amount under 200 USD?}
    C -->|No| E{Team lead approves?}
    D -->|Yes| F[Agent issues refund]
    D -->|No| E
    E -->|Approve| F
    E -->|Decline| G[Agent sends decline reason]
    F --> H[Agent notifies customer]
    G --> H
    H --> I([Ticket closed])
```

## Steps

1. **Support agent:** Log the request as a ticket tagged refund, with the order number.
2. **Support agent:** Check the order date. If it's within 30 days, go to step 3. Otherwise go to step 5.
3. **Support agent:** Check the amount. If it's under 200 USD, go to step 4. Otherwise go to step 5.
4. **Support agent:** Refund to the original payment method. Go to step 6.
5. **Team lead:** Review within 1 business day. Approve (go to step 4) or decline with a written reason (go to step 6).
6. **Support agent:** Email the outcome and expected timing, then close the ticket.

## Decision points

| Decision | If yes | If no | Map node |
|---|---|---|---|
| Order within 30 days? | Step 3 | Step 5 | C |
| Amount under 200 USD? | Step 4 | Step 5 | D |
| Team lead approves? | Step 4 | Decline, step 6 | E |

## Exceptions

| Trigger | What to do | Who decides |
|---|---|---|
| Customer opened a chargeback with their bank | Stop. Don't refund. Move the ticket to the disputes queue | Finance |
| Order paid with a gift card | Refund as store credit, not to a card | Support agent |
| Third refund request from the same customer in 90 days | Send to step 5 whatever the amount | Team lead |

## Related documents

- Returns policy (public help page)
- Wholesale credit notes process

## Change log

| Date | Change | By |
|---|---|---|
| 2026-11-02 | Raised the agent limit from 100 to 200 USD | Support lead |
| 2026-05-04 | First version | Support lead |

Try a cut-down version below. The metadata table, numbered steps and exceptions render in the preview, and the flowchart draws live. Change the 30-day rule in the diagram and watch the map update as you type.

Process: Refund request

Field Value
Owner Support lead
Trigger Customer asks for a refund
Next review 2027-05-01
flowchart TD
A[Request received] --> B{Within 30 days?}
B -->|Yes| C[Approve refund]
B -->|No| D[Escalate to manager]
C --> E[Notify customer]
D --> E

Steps

  1. Log the request in the ticket queue
  2. Check the order date
  3. Approve or escalate

Exceptions

  • Payment disputed with the bank: stop and escalate
87 words479 characters24 lines
Markdown

How Do You Document a Process Step by Step?

You document a process by watching it run, not by recalling it from memory. Sit with the person who does the work, follow one real case from trigger to finish, and write as you go. A first draft from memory usually skips the checks people do without thinking, and those are exactly the steps a new hire needs. Then fill the template in this order:

  1. Fix the boundaries first. Write the trigger and the end state before any steps. Everything between them is in scope.
  2. Write each step verb-first, with its role. "Support agent: check the order date" beats "the order date should be checked".
  3. Stop at every decision. Write the question, then both answers and where each one goes. A step with only one branch is a sign you missed something.
  4. Draw the map from the steps. One node per step, one diamond per decision. If the map and the list disagree, one of them is wrong.
  5. List the exceptions you saw. Ask the person doing the work what broke last month. Those answers are your exceptions table.
  6. Get the owner to read it. The owner confirms it, sets the next review date and adds the first change log row.

Numbered lists keep step references stable, and you can nest sub-steps under a step when one action has parts. Our guide to Markdown lists covers the numbering and indentation rules.

Decision Points and Exceptions: The Part Most Templates Skip

Most process documents describe the happy path and stop. The trouble starts when a real case takes the other branch, because that's when people improvise. Two people facing the same odd case then make two different calls, and nobody can say which was right. Two habits fix this.

First, write every decision in the steps as "If X, go to step N. Otherwise go to step M." Then give the matching diamond on the map the same question and label both arrows. The Decision points table ties the three together: question, branch targets and the map node letter. Anyone checking the doc can trace one decision through all three places in seconds.

Second, keep exceptions out of the main steps. Each row in the Exceptions table needs a trigger you can recognise, a concrete action and one role who decides. "Handle carefully" isn't an action. "Move the ticket to the disputes queue" is.

For a single run of the process, a task list works well as a checklist that someone ticks off:

- [ ] Ticket logged with the order number
- [ ] Order date and amount checked
- [ ] Customer told the outcome

GitHub renders these as checkboxes, and our editor's preview shows them as disabled checkboxes. The Markdown checkbox guide covers the syntax and where it works.

Keeping a Business Process Documentation Template Current

A business process documentation template is only useful while it matches reality, so build the upkeep into the doc itself. The Owner field names one person, not a team. The Next review date gives that person a deadline. We prefer a fixed date in the metadata over a line saying "review regularly", because a date can be missed visibly and a vague promise can't.

Each change gets a change log row with what changed and why. Keep the .md file in a Git repository and every edit to the steps, the map or the exceptions shows up as a diff. They're all plain text in one file, so one commit changes them together.

GitHub renders Mermaid diagrams in Markdown files, issues, pull requests, discussions and wikis, per GitHub Docs. GitLab renders them in Markdown too, as its Markdown documentation describes.

For readers outside the repo, paste the file into our editor and use the Download/Export menu to save it as PDF, HTML or DOCX. In the Word file, the flowchart becomes a PNG image. Without Pro, PDF, HTML and Word exports from the editor share a free pool of 3 server-side operations a day. Free toolbar exports are also capped at 5,000 characters, so a long process doc may need splitting.

One limitation to know: Mermaid flowcharts get hard to read past roughly 15 to 20 nodes. That's a readability limit, not a Mermaid rule. When a map grows that large, split it into sub-processes with their own docs and link them, or move to a dedicated BPMN tool.

Process Documentation Template FAQ

A good process documentation template keeps the steps, the map and the exceptions in one file, so nobody has to guess which version is current. Copy the blank template, fill it in from a real run of the process, and set a review date before the team starts relying on it. Paste your draft into the editor to check that the tables render and the flowchart draws, then export it for anyone who doesn't read Markdown.