Visio Sarson-Gane DFD: A Step-by-Step Guide to Creating Clear Data Flow DiagramsData Flow Diagrams (DFDs) are a cornerstone of systems analysis and design. They help teams visualize how data moves through a system, identify boundaries and interfaces, and reveal inefficiencies or missing processes. The Sarson–Gane notation (often written Gane–Sarson) is one of the most widely used DFD notations because of its clear visual grammar for processes, data stores, data flows, and external entities. Microsoft Visio is a common tool for drawing DFDs thanks to its shape libraries, alignment tools, and export options.
This guide walks you through creating clear, accurate Sarson–Gane DFDs in Visio — from planning and level scoping to drawing, labeling, validating, and sharing. It includes practical tips, common pitfalls, and suggestions for keeping diagrams consistent and useful for technical and non-technical stakeholders.
Why use Sarson–Gane notation?
- Clarity: Sarson–Gane uses distinctive shapes (rounded rectangles for processes, open-ended rectangles for data stores, arrows for data flows, and rectangles for external entities) that are easy to interpret.
- Hierarchy support: It’s designed to support leveled DFDs (context, level-1, level-2, etc.), which help manage complexity.
- Widespread adoption: Many analysts, textbooks, and organizations use this notation, making diagrams more transferable between teams.
1. Planning your DFD before opening Visio
Before you start drawing, do preparatory work — it saves time and reduces rework.
- Identify scope and level
- Decide whether you need a context diagram (single process and external entities), a level-1 diagram (major processes), or deeper levels (detailed subprocesses).
- Gather sources
- Interview stakeholders, review requirements, use cases, database schemas, and existing documentation.
- List elements
- Draft a list of external entities, processes (with unique IDs and concise names), data stores, and major data flows.
- Define conventions
- Choose naming rules, numbering scheme for processes (e.g., 0 for context, 1.0 for top-level, 1.1 for subprocess), and visual conventions (line styles, arrowheads, color for grouping).
- Sketch a rough layout on paper or whiteboard
- Map major flows to see if the planned decomposition is coherent before committing to Visio.
2. Setting up Visio for Sarson–Gane DFDs
Use the appropriate Visio template and customize stencils for Sarson–Gane notation.
- Choose a template
- Use Visio’s “Basic Flowchart” or “Software and Database” templates as a starting point. If a DFD template exists in your version, select that.
- Create/custom stencils
- Make or import Sarson–Gane shapes: rounded rectangles for processes, open-ended rectangles for data stores, rectangles for external entities, and labeled connectors for data flows.
- Page and grid setup
- Set a sensible page size (A3 or letter landscape often works), enable a grid and dynamic glue to snap shapes into alignment.
- Define styles
- Create shape and connector styles for consistent fonts, line weights, arrowheads, and colors. Save them as theme or custom styles.
3. Drawing the context diagram (level 0)
The context diagram provides a single-process view of the system and its external environment.
Steps:
- Add a single process shape (often numbered 0 or 1.0). Give it a concise name representing the whole system (e.g., “Order Processing System”).
- Place external entities around the process. Use rectangles labeled with actor names (e.g., Customer, Payment Service, Supplier).
- Draw data flows between the external entities and the system. Use labeled arrows showing what data is exchanged (e.g., “Order”, “Payment Confirmation”).
- Verify that the diagram shows only interactions with external entities — no internal data stores or detailed subprocesses.
Tips:
- Keep labels short but specific (use nouns like “Invoice”, “Order Request”).
- Limit the number of external entities to those that actually interact with the system to avoid clutter.
- Use directional arrows to indicate data movement and avoid ambiguous bi-directional arrows unless both directions carry different data.
4. Creating level-1 DFD: decomposing the main process
Level-1 expands the context process into major functional processes, data stores, and flows.
Steps:
- Decide on major processes (typically 3–7) that together realize the system’s responsibilities.
- Place processes as rounded rectangles, number them (e.g., 1.1, 1.2, 1.3) and assign concise names (e.g., “Validate Order”, “Manage Inventory”, “Process Payment”).
- Add data stores as open-ended rectangles. Name and assign identifiers (e.g., D1: Orders, D2: Inventory).
- Position external entities carried over from the context diagram at the edges.
- Draw labeled data flows connecting external entities, processes, and data stores. A flow from a process to a data store is often named with an action noun (e.g., “Store Order”), while flows between processes use nouns representing the data transferred.
- Check for balance with the context diagram: the inputs and outputs between the external entities and the system in the level-1 diagram must match those in the context diagram.
Tips:
- Maintain left-to-right or top-to-bottom logical flow where possible.
- Group related processes visually to reflect subsystems.
- Use color or subtle shading only for organizational clarity; avoid using color to imply semantics unless documented.
5. Building deeper levels (level-2 and beyond)
For complex processes, decompose a level-1 process into a level-2 diagram showing finer-grained subprocesses.
Steps:
- Choose a process to decompose and gather its inputs/outputs and related data stores.
- Follow the same drawing rules as level-1: numbered subprocesses (e.g., 1.2.1, 1.2.2), data stores, and flows.
- Ensure balancing: the inputs and outputs at the boundaries of the decomposed process must match the inputs and outputs of the parent process in level-1.
- Keep diagrams focused — each level should stay readable. If a subprocess becomes too complex, consider further decomposition or splitting responsibilities across multiple diagrams.
Balancing example (conceptual):
- If process 1.2 in level-1 receives “Order” and outputs “Shipping Notice”, then the level-2 decomposition of 1.2 must have the same external inputs/outputs at its boundary.
6. Labeling and naming conventions
Consistent names and identifiers increase readability and reduce ambiguity.
- Processes
- Use verb–noun phrasing where appropriate (e.g., “Validate Order”, “Calculate Tax”) but keep names concise.
- Assign unique numeric identifiers (context = 0 or 1.0; top-level processes 1.1, 1.2; subprocesses 1.1.1).
- Data flows
- Use nouns (e.g., “Order Details”, “Payment Confirmation”). Include format or type only when necessary (e.g., “XML Invoice”).
- Data stores
- Use nouns that describe the stored entity (e.g., “Orders”, “Customer Records”).
- Prefix with an identifier (e.g., D1, D2) to reference them in specifications.
- External entities
- Use actor names (e.g., “Customer”, “Bank API”). Avoid generic labels like “Actor 1”.
- Glossary
- Maintain a glossary that maps labels to authoritative definitions, data formats, and sample records when useful.
7. Practical Visio techniques and shortcuts
- Use dynamic connectors with routing enabled to keep flows tidy when you move shapes.
- Use shape data (right-click → Data → Shape Data) to attach attributes (ID, description, owner, associated requirements) to each shape. This helps link diagrams to documentation.
- Align and distribute tools keep layout professional and consistent.
- Layers: put annotations, reference notes, or alternative scenarios on separate layers so they can be toggled on/off.
- Container shapes or grouping can reflect logical subsystems but avoid heavy borders that detract from clarity.
- Use Visio’s validation (if available via add-ins) to check for orphaned shapes or unconnected connectors.
8. Common mistakes and how to avoid them
- Over-detailing the context diagram
- Solution: keep the context diagram to a single box and relevant external entities only.
- Unbalanced decomposition
- Solution: verify that decomposed processes’ inputs/outputs match their parent.
- Ambiguous labels
- Solution: use a glossary and prefer specific nouns for flows.
- Too many processes on a single level
- Solution: limit to 3–7 major processes; split if necessary.
- Mixing control and data flows
- Solution: DFDs model data movement; represent control logic in process descriptions or separate UML activity diagrams if needed.
- Using inconsistent notation
- Solution: define and document a notation guide in a project handbook.
9. Reviewing and validating the DFD with stakeholders
- Walkthrough sessions
- Present diagrams to technical and non-technical stakeholders to ensure mutual understanding.
- Trace real scenarios
- Step through a few concrete transactions (e.g., place an order) to confirm the diagram models actual behavior.
- Use checklist-based reviews
- Check for balanced decomposition, unique IDs, clear labels, and missing flows.
- Update iteratively
- Treat DFDs as living artifacts; update them as requirements or system design change.
10. Exporting, documenting, and sharing
- Export options
- Save as PDF or SVG for distribution; export high-resolution images for inclusion in documentation.
- Embed metadata
- Export shape data or generate reports from Visio to produce inventories of processes, data stores, and flows.
- Version control
- Use a naming convention with version numbers and dates; consider storing Visio files in a version-controlled repository (or export XML representations) if team collaboration requires rigorous versioning.
- Include companion documents
- Attach or link a glossary, process descriptions, data dictionary, and traceability matrix.
Example walkthrough (concise)
- Plan: Determine scope — “Order Processing System” context diagram.
- In Visio: Create single main process labeled 0: Order Processing System; add external entities Customer and Supplier; draw flows “Order” and “Order Acknowledgement”.
- Decompose to level-1: Create processes 1.1 (Receive Order), 1.2 (Validate & Inventory Check), 1.3 (Process Payment), 1.4 (Fulfill Order); add data stores D1: Orders, D2: Inventory, D3: Customers; add flows accordingly.
- Validate: Ensure flows between Customer and the system in level-1 match context inputs/outputs; refine labels; run walkthroughs.
- Share: Export to PDF, attach a glossary and data dictionary.
Quick checklist before finalizing a DFD
- All processes have unique IDs and clear names.
- Data flows are labeled and unambiguous.
- Data stores are identified and referenced consistently.
- External entities match those in the context diagram.
- Decompositions are balanced.
- Layout is readable and uses consistent styles.
Creating Sarson–Gane DFDs in Visio is a methodical process: plan, standardize notation, draw progressively, validate, and document. With consistent conventions and regular stakeholder reviews, DFDs become powerful tools for clarifying system behavior and guiding implementation or reengineering efforts.
Leave a Reply