Common Flowchart Symbols Explained

Flowchart symbols are visual shortcuts for explaining how a process starts, what actions happen, where decisions change the path, and how information moves. The most useful starting vocabulary is small: a rounded terminator for start or end, a rectangle for a process, a diamond for a decision, and arrows for direction. Add input/output, subprocess, document, or connector symbols only when that extra distinction helps your readers.

There is no universal meaning for every shape in every diagram. Microsoft Support explains that meanings can be agreed by the people creating and reading a flowchart, so familiar conventions should be used consistently and unusual choices should be documented in a key. Microsoft’s basic flowchart guide also notes that most flowcharts use only three or four shapes unless there is a clear business reason to add more.

Quick reference: the symbols most developers use

Symbol	Typical appearance	Meaning	Example label
Terminator	Rounded rectangle or capsule	Beginning or ending condition	Start; Request approved; End
Process	Rectangle	An action, task, or operation	Validate payment
Decision	Diamond	A question or condition that routes the flow	Payment valid?
Flowline	Line with arrowhead	Order and direction	Arrow toward next step
Input/output	Parallelogram	Information or materials entering or leaving	Read CSV file
Predefined process	Rectangle with double vertical edges	A subprocess defined elsewhere	Run fraud-check routine
Document	Rectangle with a wavy bottom	A document produced by a step	Generate invoice
On-page connector	Small circle	Continuation elsewhere on the same page	A to A
Off-page connector	Page-like reference shape	Continuation on another page or diagram	To fulfillment flow

1. Terminator: show where the flow starts and ends

The terminator is a rounded or capsule-like shape. Use it for an entry condition, a starting event, a successful completion, or an exit caused by an error. Labels should describe the condition rather than merely repeat the shape name.

Good: “Customer submits order,” “Session expires,” “Export complete.”
Weak: “Begin shape,” “End node.”

A single flow can have more than one ending. For example, a refund process might terminate at “Refund issued” or “Refund rejected.” If a diagram has several entry points, label each one so readers know which trigger they are following.

2. Process: represent an action

A rectangle means that the system or a person performs an operation. Write a concise verb phrase: “Normalize address,” “Queue email,” or “Review application.” Keep implementation detail out of the main chart unless the audience needs it. Put API names, code-level conditions, and data schemas in a linked subprocess diagram or supporting note.

One rectangle should represent one meaningful step. Combining “Validate, save, notify, and archive order” into one box hides useful failure points. Split it when the actions can fail independently, have different owners, or are reused elsewhere.

3. Decision: branch on a question or condition

The diamond represents a decision point. It asks a question whose answer determines which arrow the reader follows. Two outcomes such as “Yes” and “No” are common, but a decision can have three or more outcomes: “Plan type?” might branch to Free, Team, or Enterprise.

Put the question inside the diamond and label every outgoing arrow. “Payment valid?” with arrows labeled “Yes” and “No” is easier to scan than unlabeled lines. If the condition is evaluated by code, use the same terminology as the implementation, such as “HTTP status is 2xx?”

Keep branches mutually understandable. If one branch says “Yes” and another says “Retry,” readers may not know whether retrying is a yes or no result. Use labels such as “Yes — retry allowed” and “No — send to review” when necessary.

4. Flowline: make direction and sequence obvious

Arrowed lines connect symbols and show the order of movement. Prefer a simple top-to-bottom or left-to-right direction. Avoid crossing lines; when a crossing is unavoidable, use an on-page connector or redraw the layout.

Connect the terminator to the first process.
Connect each process to the next step or decision.
Label decision branches at the point where they leave the diamond.
Make loops visibly return to the step that repeats.

A loop should communicate its exit condition. For example, “More pages?” can return to “Fetch next page” on “Yes” and proceed to “Close cursor” on “No.”

5. Input/output: show data entering or leaving

The parallelogram marks information or materials entering or leaving a process. Use it when the data boundary matters: “Receive webhook,” “Read customer CSV,” or “Return JSON response.” It separates a data transfer from the operation that transforms that data.

Do not use the parallelogram for every variable assignment. A small internal value such as “Set retry count to zero” is normally a process. Reserve input/output for an interaction with a user, file, service, device, or other external boundary.

6. Predefined process: collapse a reusable subprocess

A predefined-process symbol is a rectangle with paired vertical edges. It tells readers that a group of steps exists elsewhere. This keeps an overview readable while preserving a path to detail.

Use it for routines such as “Authenticate request,” “Run checkout,” or “Apply tax rules” when the routine has its own diagram or documentation. Name the subprocess consistently everywhere. If the routine is only two simple steps and appears once, ordinary rectangles may be clearer.

7. Document and multiple-document symbols

The document symbol has a wavy lower edge and represents a document produced or consumed by a step: an invoice, report, signed contract, or generated file. A multiple-document variant can represent a packet or set of documents when that distinction matters.

Connect the document to the process that creates it. If a document is later reviewed, signed, or archived, show those actions as separate process boxes. This makes ownership and handoffs visible.

8. Connectors: keep large diagrams navigable

An on-page connector is usually a small circle containing a letter or number. Matching connectors show that the flow continues elsewhere on the same page without drawing a long line across other shapes. An off-page reference indicates that the path continues on another page or in a separate subprocess.

Connectors should reduce clutter, not hide logic. Use a clear naming scheme such as A-to-A and include a page or diagram title for off-page references. If a connector forces readers to search through many pages, split the diagram into a clear overview and linked detail diagrams.

9. Specialized symbols you may encounter

Flowchart libraries include additional shapes for internal storage, preparation, manual input, manual operation, and other distinctions. Microsoft’s documented shape inventory includes these and multiple-document forms. Introduce them only when the distinction changes how someone should understand or operate the process.

Use case	Possible specialized symbol	When it earns a place
Human types a value	Manual input	The human entry is a risk, approval, or compliance boundary.
Person performs a physical task	Manual operation	Automation and human work have different owners or timing.
Temporary or persistent data store	Internal storage	Storage location affects retries, privacy, or recovery.
Setup before the main work	Preparation	Initialization is a meaningful stage with its own failure modes.

10. A practical method for choosing symbols

Define the audience and scope. Decide whether the chart explains a user journey, an API request, an operations runbook, or code behavior.
Write the steps in plain language first. Use short verb phrases and questions before drawing shapes.
Start with four shapes. Use terminators, processes, decisions, and arrows. Add other shapes only when they communicate a boundary or artifact that readers need.
Mark every branch. Label outcomes such as Yes/No, Approved/Rejected, or 2xx/4xx/5xx.
Split detail into subprocesses. Replace a crowded group with a predefined-process symbol and link to a second diagram.
Add a key for local conventions. Explain any symbol whose meaning differs from the familiar convention.
Review failure paths. Include timeouts, invalid input, retries, cancellation, and terminal errors where they matter.

This method follows Microsoft’s practical guidance: familiar shapes improve recognition, but consistent agreement among the people who create and read the chart matters more than pretending every notation is universal.

11. Example: an order validation flow

Start
  |
Receive order (input/output)
  |
Validate order (process)
  |
Order valid? (decision)
  | Yes -------------------- No
  |                           |
Reserve inventory             Send rejection (process)
  |                           |
Charge payment                End
  |
Payment accepted? (decision)
  | Yes -------------------- No
  |                           |
Create invoice (document)     Release inventory
  |                           |
Send confirmation             End
  |
End

In a visual editor, the “Order valid?” and “Payment accepted?” questions would be diamonds, the actions would be rectangles, and the arrows would carry the Yes/No labels. The input/output shape clarifies the boundary where the order enters the system; the document shape calls attention to the invoice artifact.

Removing overlays before capture keeps the process diagram readable.

A clear capture pipeline turns a browser-based flowchart into a reusable documentation image.

12. Capturing a flowchart for documentation

If your diagram lives in a browser-based editor, you can capture it manually with the browser’s screenshot tools. Set the viewport, hide panels that are not part of the diagram, zoom to a readable level, and capture the full canvas. For a long flow, export a PDF or take section screenshots and connect them with on-page references.

Or skip the browser setup

ScreenshotNeo provides a website screenshot API and MCP server. Its capture process accepts cookie and consent banners as a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each step can be disabled. Bot checks and CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and response headers report the page verdict and whether the shot was billed.

Use the same endpoint from the command line:

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

Python:

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)

Node.js:

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

See the ScreenshotNeo documentation for request options. You can capture full pages with lazy images loaded, a selected element, dark mode, device presets, custom viewports, retina scale, PDFs, custom CSS and JavaScript, clicks, selector or network-idle waits, blocked resources, headers, cookies, user agents, authorization, timezone, geolocation, transparent backgrounds, resizing, caching with your chosen TTL, signed links, asynchronous jobs with signed webhooks, bulk capture of up to 100 URLs per call, usage data, and the OpenAPI specification. An MCP server exposes take_screenshot, get_page_info, and capture_pdf to Claude, Cursor, and other MCP clients.

The free plan includes 1,000 screenshots per month with no card. Paid plans start at $5 for 3,000 shots; every feature is available on every plan. Create a free ScreenshotNeo account.

13. Common mistakes and fixes

Problem	Cause	Fix
Readers cannot tell where to begin	Several unlabelled entry points or no terminator	Add a clearly labelled Start and name alternate triggers.
A diamond has confusing branches	Outgoing arrows are unlabeled or use mixed wording	Label each outcome and make the question produce those outcomes.
The chart is a wall of boxes	Every implementation detail is on one page	Keep the overview at task level and move reusable logic into subprocess diagrams.
Lines cross and direction is unclear	Layout was drawn around shapes instead of flow	Use a consistent reading direction, reroute lines, or add connectors.
Symbols look inconsistent	Different conventions were mixed	Add a key, choose one convention, and apply it throughout.
Data boundaries are hidden	Inputs and outputs were drawn as ordinary processes	Use the parallelogram for external data exchanges.
A subprocess hides an important failure	The linked detail diagram is missing or too vague	Link the symbol to a maintained detail flow and show its error outcomes.

14. Performance, reliability, and maintenance

Flowcharts are communication artifacts, so their practical performance is measured by how quickly a reader can trace a path. Keep labels short, align shapes to a grid, and avoid decorative symbols that do not change interpretation. For operational diagrams, include retry limits, timeout behavior, idempotency, and the owner of each manual step.

Version the diagram with the process it describes. A stale flowchart can be worse than no chart because it creates false confidence. Put an owner, last-reviewed date, and source link near the diagram. When a subprocess changes, update its overview connector and any runbooks that depend on its outcomes.

For browser captures, reliability depends on the page loading consistently, fonts and images being available, and overlays not covering the diagram. Wait for a selector or network idle when the editor renders asynchronously, and use a stable viewport for repeatable images. Cache only when the source is stable and a cached capture is acceptable.

15. Cost considerations for automated captures

Manual screenshots have no API charge but consume review time and are difficult to reproduce. Automated capture is useful for documentation builds, visual regression checks, and scheduled reports. Batch URLs when a workflow contains many diagrams, use a cache TTL for unchanged pages, and choose image or PDF output based on the reader’s need.

ScreenshotNeo bills only clean shots. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits cost nothing, with the result identified by response headers. This can make failure handling easier to account for, while your own application should still record HTTP errors, retries, and output validation.

FAQ

What does a diamond mean in a flowchart?

It means a decision or condition that routes the process into different outcomes. Label every outgoing arrow.

Does every flowchart need every symbol?

No. Start with terminators, processes, decisions, and arrows. Add other symbols when inputs, documents, subprocesses, or navigation need to be explicit.

Can one decision have more than two outcomes?

Yes. Two outcomes are common, but a decision can branch to several named results.

Is there a universal flowchart standard?

Common conventions exist, but Microsoft notes that meanings are not universal. Explain specialized conventions and use them consistently.

When should I use a subprocess symbol?

Use it when a group of steps is defined elsewhere, reused, or too detailed for the overview.

What is the difference between a process and input/output symbol?

A process performs an action. The parallelogram marks information or materials crossing into or out of the process.

Where can I find historical symbol references?

IBM describes early flowchart history and ASME’s 1947 symbol set, while GovInfo catalogs the 1970 FIPS 24 publication Flowchart Symbols and Their Usage in Information Processing. These are historical references, not proof that every modern diagram uses one binding notation.