{"id":1697,"date":"2026-02-25T10:44:54","date_gmt":"2026-02-25T10:44:54","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-activity-diagram-decisions\/"},"modified":"2026-02-25T10:44:54","modified_gmt":"2026-02-25T10:44:54","slug":"uml-activity-diagram-decisions","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-activity-diagram-decisions\/","title":{"rendered":"Handling Decisions and Loops in Activities"},"content":{"rendered":"<p>When you can trace a workflow from start to finish\u2014especially one involving choices or repetition\u2014you&#8217;re already thinking like a systems designer. That clarity starts with mastering how decisions and loops appear in activity diagrams. These aren\u2019t just visual flourishes; they\u2019re the backbone of modeling real-world logic in software.<\/p>\n<p>As someone who\u2019s guided dozens of teams through their first enterprise-grade process models, I\u2019ve seen how misusing decision nodes or poorly structured loops lead to confusion, rework, and missed edge cases. The good news? With a few core principles, you can draw decisions that are both accurate and readable from day one.<\/p>\n<p>This chapter walks you through the essential components: decision nodes, guards, merge nodes, and loop constructs. You\u2019ll learn how to structure branching in activity UML so that every path is intentional, and every loop is bounded and understandable. You&#8217;ll also avoid common pitfalls that trip up beginners and even experienced modelers.<\/p>\n<h2>Understanding Decision Nodes in UML Activity<\/h2>\n<p>Decision nodes are the gatekeepers of logic in activity diagrams. Think of them as traffic lights for your process\u2014one incoming flow splits into multiple outgoing paths based on conditions.<\/p>\n<p>Every decision node has a single incoming control flow, but two or more outgoing flows. Each outgoing path must be labeled with a guard condition, which is a boolean expression that determines whether that path is taken.<\/p>\n<p>Here\u2019s a simple example: a login process may decide whether to allow access based on username and password. The decision node is the point where the system checks if the credentials match.<\/p>\n<p>Always use a small diamond shape to represent a decision node. Use <strong>clear, concise conditions<\/strong>\u2014never vague phrases like \u201cif valid.\u201d Instead, write: <code>username != null AND password.length &gt;= 6<\/code>.<\/p>\n<h3>Key Rules for Decision Nodes<\/h3>\n<ul>\n<li>Only one incoming control flow is allowed.<\/li>\n<li>Outgoing flows must be labeled with guard conditions in square brackets: <code>[condition]<\/code>.<\/li>\n<li>Guards should be mutually exclusive and collectively exhaustive (MECE) where possible.<\/li>\n<li>Use the same condition language across all paths to avoid confusion.<\/li>\n<\/ul>\n<p>When you\u2019re drawing a decision node, ask: \u201cDoes every possible outcome have a path?\u201d If not, your model is incomplete.<\/p>\n<h2>Mastering Guards: The Logic Behind Branching<\/h2>\n<p>Guards are the engine that powers decision-making. They define the exact conditions under which a path is followed.<\/p>\n<p>Let\u2019s say you\u2019re modeling a customer support workflow. After a ticket is submitted, the system checks its priority. The decision node would have three outgoing flows:<\/p>\n<ul>\n<li><code>[priority == \"High\"]<\/code> \u2192 Assign to senior agent<\/li>\n<li><code>[priority == \"Medium\"]<\/code> \u2192 Assign to regular agent<\/li>\n<li><code>[priority == \"Low\"]<\/code> \u2192 Queue for later<\/li>\n<\/ul>\n<p>Notice the use of equality checks. These are preferred over phrases like \u201cif high priority.\u201d The formal syntax ensures that the model is both executable and verifiable.<\/p>\n<p>Guards can include variables, operators, and even simple method calls. But keep them <strong>as simple as possible<\/strong>. Avoid complex expressions like <code>isUserActive() AND (hasSupportPlan OR isPremiumUser)<\/code>\u2014break them down if they cause clutter.<\/p>\n<h3>Best Practice: Use Guard Expressions Wisely<\/h3>\n<p>Here\u2019s a comparison of good vs. bad guard usage:<\/p>\n<table>\n<tbody>\n<tr>\n<th>Good Guard<\/th>\n<th>Poor Guard<\/th>\n<\/tr>\n<tr>\n<td><code>[age &gt;= 18]<\/code><\/td>\n<td><code>[user is adult]<\/code><\/td>\n<\/tr>\n<tr>\n<td><code>[status == \"Pending\"] AND [timeout &lt; 24]<\/code><\/td>\n<td><code>[waiting for approval]<\/code><\/td>\n<\/tr>\n<tr>\n<td><code>[items.count &gt; 0]<\/code><\/td>\n<td><code>[has items]<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>The first column uses unambiguous expressions. The second relies on interpretation, which can lead to ambiguity during reviews.<\/p>\n<h2>Handling Loops in Activity Diagrams<\/h2>\n<p>Loops in activity diagrams model repeated actions\u2014especially useful for processing lists, files, or batches.<\/p>\n<p>There are two primary types: <strong>while loops<\/strong> and <strong>for loops<\/strong>. In UML, these are typically represented using a loop node with a condition and a repetition body.<\/p>\n<p>For example, processing a list of order items:<\/p>\n<ol>\n<li>Start<\/li>\n<li>Set index = 0<\/li>\n<li>Decision: Is index &lt; list.size()?<\/li>\n<li>If yes: Process item at index, increment index, loop back<\/li>\n<li>If no: End<\/li>\n<\/ol>\n<p>Use the <strong>loop node<\/strong> structure to keep repetition clear. It contains a condition (e.g., <code>index &lt; list.size()<\/code>) and a body that runs repeatedly.<\/p>\n<h3>When to Use Loop Nodes<\/h3>\n<ul>\n<li>When processing arrays, lists, or streams.<\/li>\n<li>When the number of iterations is not predetermined but depends on data.<\/li>\n<li>When modeling batch jobs (e.g., processing daily logs).<\/li>\n<\/ul>\n<p>Never use loops for simple sequential steps. That\u2019s what control flows are for.<\/p>\n<h2>Using Merge Nodes to Rejoin Flows<\/h2>\n<p>After branching, you\u2019ll often need to rejoin flows. That\u2019s where merge nodes come in.<\/p>\n<p>A merge node accepts multiple incoming control flows and produces one outgoing flow. It\u2019s essentially the opposite of a decision node.<\/p>\n<p>For example: a user can be either a guest or a registered user. Both paths lead to a \u201cshow dashboard\u201d action. The merge node ensures the process continues regardless of the path taken.<\/p>\n<p>Use merge nodes to avoid creating multiple end points. They\u2019re especially helpful when you want to combine multiple success paths after a decision.<\/p>\n<h3>When to Use Merge Nodes<\/h3>\n<ul>\n<li>After a decision with multiple paths that all lead to the same next action.<\/li>\n<li>To unify flows that were split by a fork (parallelism).<\/li>\n<li>To simplify complex diagrams with redundant endpoints.<\/li>\n<\/ul>\n<p>Always ensure the incoming flows are logically compatible. If one path ends in an error and another in success, merging them prematurely can mislead.<\/p>\n<h2>Practical Tips for Clear Branching in Activity UML<\/h2>\n<p>Here are real-world techniques I\u2019ve used with teams to keep activity diagrams readable and maintainable:<\/p>\n<ol>\n<li><strong>Group related decisions<\/strong>: Avoid placing decision nodes too far apart. If you have multiple decisions in a row, consider grouping them into a single decision block.<\/li>\n<li><strong>Label guards consistently<\/strong>: Use the same variable names and operators across all guards. Avoid mixing \u201cage &gt; 18\u201d with \u201cage &gt;= 18\u201d.<\/li>\n<li><strong>Limit decisions per page<\/strong>: If your diagram has more than 3 decision nodes, consider breaking it into sub-processes.<\/li>\n<li><strong>Use swimlanes for ownership<\/strong>: Assign decision points to specific roles or departments to clarify responsibility.<\/li>\n<li><strong>Test with real data<\/strong>: Walk through your diagram using sample inputs. Does it behave as expected? This is the fastest way to catch logic errors.<\/li>\n<\/ol>\n<h2>Common Pitfalls to Avoid<\/h2>\n<p>Even experienced modelers make these mistakes. Avoid them early to save time later.<\/p>\n<ul>\n<li><strong>Missing guards<\/strong>: All outgoing flows from a decision node must have a guard. Omitting one leads to ambiguity.<\/li>\n<li><strong>Overusing nested decisions<\/strong>: Deep nesting (e.g., decision \u2192 decision \u2192 decision) makes diagrams hard to read. Refactor into separate diagrams or use subroutines.<\/li>\n<li><strong>Unreachable paths<\/strong>: A guard like <code>[false]<\/code> creates a dead end. Always validate that each path can be reached.<\/li>\n<li><strong>Confusing merge with decision<\/strong>: Remember: decision splits; merge joins. Don\u2019t swap them by accident.<\/li>\n<li><strong>Loop without exit<\/strong>: A while loop must have a condition that eventually becomes false. Otherwise, you create an infinite loop.<\/li>\n<\/ul>\n<h2>Real Example: Modeling a User Registration Process<\/h2>\n<p>Let\u2019s walk through a simple but realistic example: a user registration system.<\/p>\n<ol>\n<li>Start<\/li>\n<li>Enter email and password<\/li>\n<li>Decision: Is email valid? \u2192 <code>[email.matches(\/^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$\/)]<\/code><\/li>\n<ul>\n<li>Yes \u2192 Continue<\/li>\n<li>No \u2192 Show error, loop back<\/li>\n<\/ul>\n<li>Decision: Is password strong? \u2192 <code>[password.length &gt;= 8 AND containsLetter AND containsDigit]<\/code><\/li>\n<ul>\n<li>Yes \u2192 Continue<\/li>\n<li>No \u2192 Show error, loop back<\/li>\n<\/ul>\n<li>Decision: Is email already registered? \u2192 <code>[!isRegistered(email)]<\/code><\/li>\n<ul>\n<li>Yes \u2192 Show error, loop back<\/li>\n<li>No \u2192 Create user<\/li>\n<\/ul>\n<li>Send welcome email<\/li>\n<li>End<\/li>\n<\/ol>\n<p>This example uses decision nodes, guards, loops, and merge-like behavior (via multiple paths leading to the same action). Notice how each step is testable and unambiguous.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>What is a decision node in UML activity?<\/h3>\n<p>A decision node is a diamond-shaped symbol that splits a single incoming control flow into multiple outgoing flows based on condition checks. Each outgoing path must be labeled with a guard condition.<\/p>\n<h3>Can I have multiple decision nodes in one activity diagram?<\/h3>\n<p>Absolutely. But keep the number manageable. More than three in a row may suggest the need for sub-processes or a refactored design.<\/p>\n<h3>How do I represent a while loop in an activity diagram?<\/h3>\n<p>Use a loop node with a condition and a body. The flow starts inside the loop, checks the condition at the end, and loops back if true. Use the loop construct to make repetition explicit and bounded.<\/p>\n<h3>Why use merge nodes instead of just connecting flows?<\/h3>\n<p>Merge nodes ensure that multiple flows can converge without ambiguity. They prevent accidental creation of multiple end points and clarify that all paths lead to the same next step.<\/p>\n<h3>What\u2019s the difference between a decision and a merge node?<\/h3>\n<p>Decision nodes split a flow into multiple paths based on conditions. Merge nodes join multiple incoming flows into one outgoing flow. They are complementary: decision \u2192 merge \u2192 next action.<\/p>\n<h3>Can I use activity diagrams for business process modeling?<\/h3>\n<p>Yes. Activity diagrams are excellent for modeling business workflows\u2014especially when they involve decisions, loops, and responsibilities. They\u2019re widely used in BPMN and enterprise process documentation.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>When you can trace a workflow from start to finish\u2014especially one involving choices or repetition\u2014you&#8217;re already thinking like a systems designer. That clarity starts with mastering how decisions and loops appear in activity diagrams. These aren\u2019t just visual flourishes; they\u2019re the backbone of modeling real-world logic in software. As someone who\u2019s guided dozens of teams [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":1695,"menu_order":1,"template":"","meta":{"_acf_changed":false,"inline_featured_image":false,"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"doc_tag":[],"class_list":["post-1697","docs","type-docs","status-publish","hentry"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v27.2 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Mastering Activity Diagram Decisions<\/title>\n<meta name=\"description\" content=\"Learn to model decision nodes, guards, and loops in activity diagrams to represent conditional and iterative logic clearly. Master branching in activity UML with real examples and best practices.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-activity-diagram-decisions\/\" \/>\n<meta property=\"og:locale\" content=\"pl_PL\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Mastering Activity Diagram Decisions\" \/>\n<meta property=\"og:description\" content=\"Learn to model decision nodes, guards, and loops in activity diagrams to represent conditional and iterative logic clearly. Master branching in activity UML with real examples and best practices.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-activity-diagram-decisions\/\" \/>\n<meta property=\"og:site_name\" content=\"Visual Paradigm Skills Polski\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Szacowany czas czytania\" \/>\n\t<meta name=\"twitter:data1\" content=\"7 minut\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-activity-diagram-decisions\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-activity-diagram-decisions\/\",\"name\":\"Mastering Activity Diagram Decisions\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/#website\"},\"datePublished\":\"2026-02-25T10:44:54+00:00\",\"description\":\"Learn to model decision nodes, guards, and loops in activity diagrams to represent conditional and iterative logic clearly. Master branching in activity UML with real examples and best practices.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-activity-diagram-decisions\/#breadcrumb\"},\"inLanguage\":\"pl-PL\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-activity-diagram-decisions\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-activity-diagram-decisions\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pl\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"UML Basics: Diagrams for Beginners\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Activity Diagrams for Process Visualization\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Handling Decisions and Loops in Activities\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/#website\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pl\/\",\"name\":\"Visual Paradigm Skills Polski\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/skills.visual-paradigm.com\/pl\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"pl-PL\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/#organization\",\"name\":\"Visual Paradigm Skills Polski\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pl\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"pl-PL\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pl\/wp-content\/uploads\/sites\/8\/2026\/02\/favicon.svg\",\"contentUrl\":\"https:\/\/skills.visual-paradigm.com\/pl\/wp-content\/uploads\/sites\/8\/2026\/02\/favicon.svg\",\"width\":70,\"height\":70,\"caption\":\"Visual Paradigm Skills Polski\"},\"image\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Mastering Activity Diagram Decisions","description":"Learn to model decision nodes, guards, and loops in activity diagrams to represent conditional and iterative logic clearly. Master branching in activity UML with real examples and best practices.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-activity-diagram-decisions\/","og_locale":"pl_PL","og_type":"article","og_title":"Mastering Activity Diagram Decisions","og_description":"Learn to model decision nodes, guards, and loops in activity diagrams to represent conditional and iterative logic clearly. Master branching in activity UML with real examples and best practices.","og_url":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-activity-diagram-decisions\/","og_site_name":"Visual Paradigm Skills Polski","twitter_card":"summary_large_image","twitter_misc":{"Szacowany czas czytania":"7 minut"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-activity-diagram-decisions\/","url":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-activity-diagram-decisions\/","name":"Mastering Activity Diagram Decisions","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/pl\/#website"},"datePublished":"2026-02-25T10:44:54+00:00","description":"Learn to model decision nodes, guards, and loops in activity diagrams to represent conditional and iterative logic clearly. Master branching in activity UML with real examples and best practices.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-activity-diagram-decisions\/#breadcrumb"},"inLanguage":"pl-PL","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-activity-diagram-decisions\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-activity-diagram-decisions\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/pl\/"},{"@type":"ListItem","position":2,"name":"UML Basics: Diagrams for Beginners","item":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/"},{"@type":"ListItem","position":3,"name":"Activity Diagrams for Process Visualization","item":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/"},{"@type":"ListItem","position":4,"name":"Handling Decisions and Loops in Activities"}]},{"@type":"WebSite","@id":"https:\/\/skills.visual-paradigm.com\/pl\/#website","url":"https:\/\/skills.visual-paradigm.com\/pl\/","name":"Visual Paradigm Skills Polski","description":"","publisher":{"@id":"https:\/\/skills.visual-paradigm.com\/pl\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/skills.visual-paradigm.com\/pl\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"pl-PL"},{"@type":"Organization","@id":"https:\/\/skills.visual-paradigm.com\/pl\/#organization","name":"Visual Paradigm Skills Polski","url":"https:\/\/skills.visual-paradigm.com\/pl\/","logo":{"@type":"ImageObject","inLanguage":"pl-PL","@id":"https:\/\/skills.visual-paradigm.com\/pl\/#\/schema\/logo\/image\/","url":"https:\/\/skills.visual-paradigm.com\/pl\/wp-content\/uploads\/sites\/8\/2026\/02\/favicon.svg","contentUrl":"https:\/\/skills.visual-paradigm.com\/pl\/wp-content\/uploads\/sites\/8\/2026\/02\/favicon.svg","width":70,"height":70,"caption":"Visual Paradigm Skills Polski"},"image":{"@id":"https:\/\/skills.visual-paradigm.com\/pl\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/docs\/1697","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/docs"}],"about":[{"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/types\/docs"}],"author":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/docs\/1697\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/docs\/1695"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/media?parent=1697"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/doc_tag?post=1697"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}