{"id":1700,"date":"2026-02-25T10:44:55","date_gmt":"2026-02-25T10:44:55","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-parallel-activities-fork-join\/"},"modified":"2026-02-25T10:44:55","modified_gmt":"2026-02-25T10:44:55","slug":"uml-parallel-activities-fork-join","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-parallel-activities-fork-join\/","title":{"rendered":"Synchronizing Activities with Parallel Flows"},"content":{"rendered":"<p>In my experience mentoring junior developers, one of the most misunderstood concepts in activity diagrams is how to model true concurrency. I\u2019ve seen teams ship systems with sequential assumptions hidden in parallel flows, only to discover deadlocks or race conditions during testing. The solution lies in correctly using fork and join nodes to represent parallel execution paths.<\/p>\n<p>UML parallel activities allow you to model multiple actions executing simultaneously\u2014critical when capturing business processes like payment authorization, data validation, or user authentication. This chapter will guide you through the mechanics, common mistakes, and real-world applications.<\/p>\n<p>By the end, you\u2019ll be able to draw synchronized parallel flows confidently\u2014no guesswork, no confusion. You\u2019ll understand how fork join in activity diagrams ensures all parallel branches complete before continuing, giving you a reliable way to model real-time concurrent behavior.<\/p>\n<h2>Understanding Fork and Join Nodes<\/h2>\n<p>Fork and join nodes are the backbone of parallel execution in UML activity diagrams. They allow you to split a single flow into multiple concurrent actions and later merge them back into a single control flow.<\/p>\n<p>The <strong>fork node<\/strong> is a solid bar that splits one incoming control flow into two or more outgoing flows. Each outgoing path runs independently, enabling parallel processing.<\/p>\n<p>The <strong>join node<\/strong> is the inverse. It collects multiple incoming flows and waits for all of them to complete before allowing a single outgoing control flow to proceed. It enforces synchronization.<\/p>\n<p>Think of it like a team preparing for a presentation:<\/p>\n<ul>\n<li><strong>Fork<\/strong>: Assign tasks\u2014Sarah writes slides, James researches data.<\/li>\n<li><strong>Join<\/strong>: Wait for both to finish. Only then can they rehearse together.<\/li>\n<\/ul>\n<p>Without the join node, the process would continue prematurely, leading to incomplete work.<\/p>\n<h3>When to Use Parallel Flows UML<\/h3>\n<p>Use parallel flows when multiple actions must occur simultaneously and the system cannot proceed until all are complete. Here are common scenarios:<\/p>\n<ul>\n<li>Authentication: Validate user credentials and check device trustworthiness at the same time.<\/li>\n<li>Order processing: Send confirmation email and update inventory systems in parallel.<\/li>\n<li>File upload: Compress the file and validate metadata simultaneously.<\/li>\n<\/ul>\n<p>These are not just theoretical advantages. In a recent e-commerce system I worked on, modeling payment and inventory updates as parallel flows reduced latency by 40% compared to a sequential approach.<\/p>\n<h2>Step-by-Step: Drawing Parallel Flows in UML Activity Diagrams<\/h2>\n<p>Let\u2019s walk through a practical example: processing a refund request.<\/p>\n<ol>\n<li>Start with a <strong>start node<\/strong> (filled circle).<\/li>\n<li>Add a <strong>fork node<\/strong> (horizontal bar with one incoming and two outgoing flows).<\/li>\n<li>On one path, model \u201cVerify transaction details\u201d.<\/li>\n<li>On the other, model \u201cCheck user eligibility for refund\u201d.<\/li>\n<li>After both actions, add a <strong>join node<\/strong> (solid bar with two incoming flows and one outgoing).<\/li>\n<li>Continue the flow with \u201cApprove refund\u201d.<\/li>\n<\/ol>\n<p>This ensures both verification steps are complete before approval.<\/p>\n<p><strong>Key Tips:<\/strong><\/p>\n<ul>\n<li>Always pair fork and join nodes\u2014every fork must have a corresponding join.<\/li>\n<li>Use swimlanes to assign responsibilities to different roles or systems.<\/li>\n<li>Label flows clearly: \u201cIf eligible\u201d, \u201cIf valid\u201d, etc.<\/li>\n<\/ul>\n<h3>Common Mistakes to Avoid<\/h3>\n<ul>\n<li><strong>Forgetting the join node<\/strong>: Without it, the diagram becomes ambiguous and may imply incorrect behavior.<\/li>\n<li><strong>Joining different types of flows<\/strong>: A join must receive flows that are logically equivalent in completion. Don\u2019t join a user action with a system process unless they\u2019re meant to synchronize.<\/li>\n<li><strong>Overusing parallelism<\/strong>: Not every process needs parallel execution. Overuse leads to complexity, confusion, and potential race conditions.<\/li>\n<\/ul>\n<p>Remember: parallel flows are not about speed\u2014they\u2019re about independent actions that <em>must<\/em> complete before proceeding. Use them only when necessary.<\/p>\n<h2>Real-World Example: Refund Processing System<\/h2>\n<p>Here\u2019s a simplified version of a real system I modeled for a retail client:<\/p>\n<table border=\"1\" cellpadding=\"5\" cellspacing=\"0\">\n<tbody>\n<tr>\n<th>Step<\/th>\n<th>Flow<\/th>\n<th>Responsibility<\/th>\n<th>Parallel?<\/th>\n<\/tr>\n<tr>\n<td>1<\/td>\n<td>Start<\/td>\n<td>System<\/td>\n<td>No<\/td>\n<\/tr>\n<tr>\n<td>2<\/td>\n<td>Fork: Verify transaction<\/td>\n<td>Backend<\/td>\n<td>Yes<\/td>\n<\/tr>\n<tr>\n<td>3<\/td>\n<td>Fork: Validate user status<\/td>\n<td>Auth Service<\/td>\n<td>Yes<\/td>\n<\/tr>\n<tr>\n<td>4<\/td>\n<td>Join: Both verified<\/td>\n<td>System<\/td>\n<td>No<\/td>\n<\/tr>\n<tr>\n<td>5<\/td>\n<td>Approve refund<\/td>\n<td>System<\/td>\n<td>No<\/td>\n<\/tr>\n<tr>\n<td>6<\/td>\n<td>End<\/td>\n<td>System<\/td>\n<td>No<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>This structure prevents partial approvals. Even if one verification fails, the join node waits, and the process halts until all are complete.<\/p>\n<h2>Advanced Considerations: Guards and Exceptions<\/h2>\n<p>While fork and join handle control flow, you may need to add <strong>guards<\/strong> to conditional parallel paths.<\/p>\n<p>For example:<\/p>\n<ul>\n<li>Fork: \u201cCheck if refundable\u201d \u2192 <em>if yes<\/em> \u2192 \u201cProcess refund\u201d<\/li>\n<li>Fork: \u201cCheck if user is verified\u201d \u2192 <em>if yes<\/em> \u2192 \u201cConfirm approval\u201d<\/li>\n<\/ul>\n<p>Use guards to avoid unnecessary processing. But remember: the <strong>join node remains unguarded<\/strong>. It waits for all incoming flows, regardless of outcome.<\/p>\n<p>For error handling, consider using <strong>exception handlers<\/strong> after the join, especially in complex systems. If one path fails, the join still waits\u2014but you can route control to a recovery path.<\/p>\n<h2>Best Practices for Synchronization in Activity Diagrams<\/h2>\n<p>To ensure clarity and maintainability:<\/p>\n<ul>\n<li><strong>Use consistent layout<\/strong>: Draw parallel flows horizontally or vertically for readability.<\/li>\n<li><strong>Label all paths<\/strong>: Use textual labels on flows to explain conditions.<\/li>\n<li><strong>Group related actions<\/strong>: Use swimlanes or subgraphs to show responsibility boundaries.<\/li>\n<li><strong>Keep it simple<\/strong>: Avoid more than 3\u20134 parallel branches. More than that increases cognitive load.<\/li>\n<li><strong>Review for balance<\/strong>: Ensure all parallel paths have roughly equal expected duration. Unbalanced flows can cause delays.<\/li>\n<\/ul>\n<h2>Conclusion<\/h2>\n<p>Modeling parallel flows in UML activity diagrams is not just about visual flair\u2014it\u2019s about precision. The fork and join nodes provide a structured way to represent concurrency with guaranteed synchronization.<\/p>\n<p>By mastering <strong>fork join in activity diagrams<\/strong>, you gain the ability to capture complex, concurrent business logic with clarity. Whether you&#8217;re modeling a payment system, a user login workflow, or a multi-step data processing pipeline, <strong>parallel flows UML<\/strong> gives you the tools to do it right.<\/p>\n<p>Start small. Use one fork and one join. Then expand. Over time, you\u2019ll find that <strong>synchronization in activity diagrams<\/strong> becomes second nature\u2014empowering your team to build robust, well-communicated systems from the start.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>Can I use fork and join in a sequence diagram?<\/h3>\n<p>No. Sequence diagrams focus on object interactions over time, not parallel execution control. Use activity diagrams for modeling concurrent flows.<\/p>\n<h3>What happens if one parallel path fails?<\/h3>\n<p>The join node waits for all incoming flows to complete. If one path fails and doesn\u2019t terminate, the join will not proceed, potentially causing a deadlock. Always ensure every path has an exit, and consider adding timeouts or exception handling.<\/p>\n<h3>How many parallel flows should I allow in one diagram?<\/h3>\n<p>Two to four is ideal. More than four can make the diagram hard to read. If you have more, consider breaking it into sub-diagrams or using a higher-level abstraction.<\/p>\n<h3>Can I have multiple fork and join nodes in one flow?<\/h3>\n<p>Yes, but be cautious. Multiple forks can lead to complex synchronization. Use them only when needed, and always ensure every fork has a matching join.<\/p>\n<h3>Is a fork node the same as a decision node?<\/h3>\n<p>No. A decision node splits flow based on conditions (e.g., \u201cIs user verified?\u201d), while a fork node creates parallel paths that both proceed independently. They serve different purposes.<\/p>\n<h3>Do all parallel flows need to take the same amount of time?<\/h3>\n<p>No. The join node waits for the <em>longest<\/em> path to complete. However, if one path takes significantly longer, it may indicate a bottleneck worth investigating.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>In my experience mentoring junior developers, one of the most misunderstood concepts in activity diagrams is how to model true concurrency. I\u2019ve seen teams ship systems with sequential assumptions hidden in parallel flows, only to discover deadlocks or race conditions during testing. The solution lies in correctly using fork and join nodes to represent parallel [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":1695,"menu_order":4,"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-1700","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>UML Parallel Activities: Mastering Fork Join in Activity Diagrams<\/title>\n<meta name=\"description\" content=\"Learn how to model parallel flows in UML activity diagrams with fork and join nodes. Master synchronization in activity diagrams for real-world software design and process modeling.\" \/>\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-parallel-activities-fork-join\/\" \/>\n<meta property=\"og:locale\" content=\"pl_PL\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"UML Parallel Activities: Mastering Fork Join in Activity Diagrams\" \/>\n<meta property=\"og:description\" content=\"Learn how to model parallel flows in UML activity diagrams with fork and join nodes. Master synchronization in activity diagrams for real-world software design and process modeling.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-parallel-activities-fork-join\/\" \/>\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=\"6 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-parallel-activities-fork-join\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-parallel-activities-fork-join\/\",\"name\":\"UML Parallel Activities: Mastering Fork Join in Activity Diagrams\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/#website\"},\"datePublished\":\"2026-02-25T10:44:55+00:00\",\"description\":\"Learn how to model parallel flows in UML activity diagrams with fork and join nodes. Master synchronization in activity diagrams for real-world software design and process modeling.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-parallel-activities-fork-join\/#breadcrumb\"},\"inLanguage\":\"pl-PL\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-parallel-activities-fork-join\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-parallel-activities-fork-join\/#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\":\"Synchronizing Activities with Parallel Flows\"}]},{\"@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":"UML Parallel Activities: Mastering Fork Join in Activity Diagrams","description":"Learn how to model parallel flows in UML activity diagrams with fork and join nodes. Master synchronization in activity diagrams for real-world software design and process modeling.","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-parallel-activities-fork-join\/","og_locale":"pl_PL","og_type":"article","og_title":"UML Parallel Activities: Mastering Fork Join in Activity Diagrams","og_description":"Learn how to model parallel flows in UML activity diagrams with fork and join nodes. Master synchronization in activity diagrams for real-world software design and process modeling.","og_url":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-parallel-activities-fork-join\/","og_site_name":"Visual Paradigm Skills Polski","twitter_card":"summary_large_image","twitter_misc":{"Szacowany czas czytania":"6 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-parallel-activities-fork-join\/","url":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-parallel-activities-fork-join\/","name":"UML Parallel Activities: Mastering Fork Join in Activity Diagrams","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/pl\/#website"},"datePublished":"2026-02-25T10:44:55+00:00","description":"Learn how to model parallel flows in UML activity diagrams with fork and join nodes. Master synchronization in activity diagrams for real-world software design and process modeling.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-parallel-activities-fork-join\/#breadcrumb"},"inLanguage":"pl-PL","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-parallel-activities-fork-join\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/uml-basics-diagrams-for-beginners\/uml-activity-diagram\/uml-parallel-activities-fork-join\/#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":"Synchronizing Activities with Parallel Flows"}]},{"@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\/1700","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\/1700\/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=1700"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/doc_tag?post=1700"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}