{"id":819,"date":"2026-02-25T10:25:09","date_gmt":"2026-02-25T10:25:09","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/dfd-vs-uml-when-to-use-each\/practical-implementation-patterns\/dfd-to-uml-developer-handoff\/"},"modified":"2026-02-25T10:25:09","modified_gmt":"2026-02-25T10:25:09","slug":"dfd-to-uml-developer-handoff","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/dfd-vs-uml-when-to-use-each\/practical-implementation-patterns\/dfd-to-uml-developer-handoff\/","title":{"rendered":"Development Handoff: From DFD to UML Sequence"},"content":{"rendered":"<p>Handing off from a functional specification modeled in a Data Flow Diagram (DFD) to detailed collaboration specifications in a UML sequence diagram is a pivotal moment in development. The transition isn\u2019t just about changing notation\u2014it\u2019s about shifting from what data moves where to how objects interact in sequence.<\/p>\n<p>Many teams struggle here because DFDs focus on processes as black boxes transforming data, while UML sequence diagrams demand explicit object identities, message timing, and state transitions. This misalignment often leads to ambiguity, missed edge cases, or developers building based on assumptions.<\/p>\n<p>I\u2019ve seen teams waste weeks on rework because a single DFD process\u2014say, \u201cProcess Payment\u201d\u2014was not properly mapped into object-level interactions like \u201cPayer sends PaymentRequest to PaymentService, which validates and notifies FraudCheck.\u201d The gap isn\u2019t technical; it\u2019s conceptual.<\/p>\n<p>This chapter provides a practical, step-by-step approach to bridge that gap. You\u2019ll learn how to extract behavioral intent from DFD processes, map them to UML message flows, and build a traceability matrix that ensures nothing gets lost in translation. You\u2019ll also discover how to onboard developers with minimal cognitive friction.<\/p>\n<h2>Mapping DFD Logic to UML Collaboration<\/h2>\n<p>The key insight is that every DFD process represents an application of behavior\u2014typically a sequence of actions involving data transformation, validation, and routing. Your job is to uncover that behavior and express it as object interactions.<\/p>\n<p>Start with the DFD process itself. Ask: What is the primary purpose of this process? Who triggers it? What data comes in? What is produced? Then reframe that in terms of object roles and message flow.<\/p>\n<h3>Step 1: Extract the Process Intent<\/h3>\n<p>Take a DFD Level 1 process such as \u201cValidate Customer Credentials.\u201d Break it down:<\/p>\n<ul>\n<li><strong>Trigger:<\/strong> User submits login form.<\/li>\n<li><strong>Data Inputs:<\/strong> Username, password hash.<\/li>\n<li><strong>Outputs:<\/strong> Authentication result (success\/failure).<\/li>\n<li><strong>Internal Actions:<\/strong> Check user existence, compare password hash, update login timestamp.<\/li>\n<\/ul>\n<p>Now reframe this in object-centric terms: Which objects are involved? What roles do they play?<\/p>\n<h3>Step 2: Identify Core Actors and Objects<\/h3>\n<p>Map the process inputs and outputs to objects. For example:<\/p>\n<ul>\n<li><strong>Actor:<\/strong> User (initiates login).<\/li>\n<li><strong>System Objects:<\/strong> AuthenticationService, UserDatabase, LoginLog.<\/li>\n<\/ul>\n<p>These become the participants in your UML sequence diagram.<\/p>\n<h3>Step 3: Translate Data Flows into Messages<\/h3>\n<p>Each data flow in the DFD becomes a message in the sequence diagram. For example:<\/p>\n<ul>\n<li>\u201cUsername, password\u201d \u2192 <code>AuthenticationService.validateCredentials(username, hash)<\/code><\/li>\n<li>\u201cValidated result\u201d \u2192 <code>return authSuccess<\/code><\/li>\n<\/ul>\n<p>Now, the sequence is clear: User \u2192 AuthenticationService \u2192 UserDatabase \u2192 AuthenticationService \u2192 User.<\/p>\n<p>Remember: The DFD process is the top-level behavior. The UML sequence diagram reveals the internal orchestration.<\/p>\n<h2>Creating the Traceability Matrix<\/h2>\n<p>Without traceability, the handoff becomes a blind leap. A traceability matrix ensures every requirement, data flow, and decision point is accounted for in the final sequence diagram.<\/p>\n<p>Use a simple two-column table to link DFD elements to UML artifacts:<\/p>\n<table border=\"1\" cellpadding=\"4\" cellspacing=\"0\">\n<tbody>\n<tr>\n<th>DFD Element<\/th>\n<th>Corresponding UML Element<\/th>\n<\/tr>\n<tr>\n<td>Process: Validate Customer Credentials<\/td>\n<td>Use Case: Authenticate User<\/td>\n<\/tr>\n<tr>\n<td>Data Flow: Username, password<\/td>\n<td>Message: <code>validateCredentials(username, hash)<\/code><\/td>\n<\/tr>\n<tr>\n<td>Data Flow: Authentication result<\/td>\n<td>Message: <code>notifyUser(authSuccess)<\/code><\/td>\n<\/tr>\n<tr>\n<td>Data Store: UserDatabase<\/td>\n<td>Object: UserDatabase (collaborator)<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>This matrix serves as both a validation tool and onboarding guide. Developers can verify they\u2019ve implemented all required behaviors.<\/p>\n<p>Update the matrix as you refine the sequence diagram. If a new validation rule emerges\u2014say, \u201clock account after 5 failed attempts\u201d\u2014add it and trace it back to the DFD process.<\/p>\n<h2>Developer Onboarding: From DFD to Sequence Diagram<\/h2>\n<p>Even with a perfect traceability matrix, developers may struggle if they\u2019re unfamiliar with how to read or interpret the transition.<\/p>\n<p>Here\u2019s how to onboard them effectively:<\/p>\n<h3>1. Start with the DFD Context<\/h3>\n<p>Give developers a one-page summary of the system\u2019s scope: context diagram, key processes, and external entities. This grounds them in the business logic before diving into code or messages.<\/p>\n<h3>2. Use the Traceability Matrix as a Map<\/h3>\n<p>Share the matrix as a guide. Show how each DFD process maps to a UML use case and sequence diagram. Highlight how data flows become function calls.<\/p>\n<p><strong>Pro Tip:<\/strong> Annotate the UML sequence diagram with DFD process numbers in the margin. This way, a developer can refer back to the original DFD for context.<\/p>\n<h3>3. Run a \u201cWalkthrough\u201d Session<\/h3>\n<p>Host a 30-minute session where you simulate the flow step by step:<\/p>\n<ol>\n<li>Start with the DFD process.<\/li>\n<li>Identify the objects involved.<\/li>\n<li>Map each data flow to a message.<\/li>\n<li>Build the sequence step by step on a whiteboard.<\/li>\n<\/ol>\n<p>This isn\u2019t about memorizing\u2014it\u2019s about building mental models.<\/p>\n<p>After the session, provide a handout with the completed sequence diagram, the traceability matrix, and a checklist: \u201cWhat to Verify When Implementing This Flow.\u201d<\/p>\n<h2>Common Pitfalls and How to Avoid Them<\/h2>\n<p>Even experienced teams fall into traps during the DFD to UML developer handoff. Anticipate them:<\/p>\n<h3>Pitfall 1: Confusing Processes with Objects<\/h3>\n<p>\u201cProcess Payment\u201d doesn\u2019t mean \u201ccreate a Payment object.\u201d It means \u201cexecute the logic to process a payment.\u201d The object is a collaborator, not the driver.<\/p>\n<p><strong>Solution:<\/strong> Use verbs to label processes in DFDs\u2014\u201cValidate,\u201d \u201cProcess,\u201d \u201cNotify\u201d\u2014and map those verbs to method calls in UML.<\/p>\n<h3>Pitfall 2: Overloading the Sequence Diagram<\/h3>\n<p>Some teams try to show every possible path\u2014success, failure, timeout\u2014on a single sequence, making it unreadable.<\/p>\n<p><strong>Solution:<\/strong> Use separate diagrams for success and error flows. Keep the main sequence clean and reference variants via notes or alternate fragments.<\/p>\n<h3>Pitfall 3: Skipping the Message Timing Layer<\/h3>\n<p>DFD doesn\u2019t model time. But real systems do. A process may take 200ms to complete, or a message may be delayed due to network latency.<\/p>\n<p><strong>Solution:<\/strong> Add timing constraints to the sequence diagram where needed. Use UML\u2019s <code>alt<\/code>, <code>opt<\/code>, and <code>par<\/code> fragments to represent conditional and concurrent logic.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>How do I handle DFD processes with no clear object roles?<\/h3>\n<p>Start by asking: \u201cWho owns this process?\u201d If it\u2019s a backend service (e.g., \u201cGenerate Monthly Report\u201d), the object is the service itself. Model it as a single object that performs internal steps. Use a sequence fragment to show internal logic.<\/p>\n<h3>Can I use UML activity diagrams instead of sequence diagrams for handoff?<\/h3>\n<p>Activity diagrams are better for control flow and decision paths. But for handoff to developers, sequence diagrams are clearer because they show object roles, message order, and lifetimes\u2014critical for implementation.<\/p>\n<h3>What if my team doesn\u2019t know UML?<\/h3>\n<p>Start small. Use UML notation only for the handoff to developers. Keep DFDs for business stakeholders. Offer a 30-minute onboarding session on reading sequence diagrams. Use real code snippets from the implementation to illustrate message patterns.<\/p>\n<h3>Should I automate the DFD to UML message mapping?<\/h3>\n<p>Not yet. The mapping is too context-sensitive. Automated tools often miss edge cases. Manual review with traceability checks is more reliable. But once the pattern is stable, you can create a template to speed up future transitions.<\/p>\n<h3>How do I ensure the sequence diagram stays in sync with the DFD?<\/h3>\n<p>Update the traceability matrix every time a change is made. Use version control to track diagram revisions. Perform a monthly cross-review with both business and development leads to validate alignment.<\/p>\n<h3>What if the DFD is too high-level for handoff?<\/h3>\n<p>Break it down into Level 1 processes. If a process like \u201cProcess Order\u201d is too broad, decompose it into sub-processes: \u201cValidate Order,\u201d \u201cCheck Inventory,\u201d \u201cConfirm Payment,\u201d \u201cUpdate Stock.\u201d Then map each to a sequence diagram.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Handing off from a functional specification modeled in a Data Flow Diagram (DFD) to detailed collaboration specifications in a UML sequence diagram is a pivotal moment in development. The transition isn\u2019t just about changing notation\u2014it\u2019s about shifting from what data moves where to how objects interact in sequence. Many teams struggle here because DFDs focus [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":816,"menu_order":2,"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-819","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>DFD to UML Developer Handoff<\/title>\n<meta name=\"description\" content=\"Master the functional spec to sequence diagram transition with traceability matrices and onboarding strategies for seamless developer handoff from DFD to UML.\" \/>\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\/dfd-vs-uml-when-to-use-each\/practical-implementation-patterns\/dfd-to-uml-developer-handoff\/\" \/>\n<meta property=\"og:locale\" content=\"pl_PL\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"DFD to UML Developer Handoff\" \/>\n<meta property=\"og:description\" content=\"Master the functional spec to sequence diagram transition with traceability matrices and onboarding strategies for seamless developer handoff from DFD to UML.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/dfd-vs-uml-when-to-use-each\/practical-implementation-patterns\/dfd-to-uml-developer-handoff\/\" \/>\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\/dfd-vs-uml-when-to-use-each\/practical-implementation-patterns\/dfd-to-uml-developer-handoff\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/dfd-vs-uml-when-to-use-each\/practical-implementation-patterns\/dfd-to-uml-developer-handoff\/\",\"name\":\"DFD to UML Developer Handoff\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/#website\"},\"datePublished\":\"2026-02-25T10:25:09+00:00\",\"description\":\"Master the functional spec to sequence diagram transition with traceability matrices and onboarding strategies for seamless developer handoff from DFD to UML.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/dfd-vs-uml-when-to-use-each\/practical-implementation-patterns\/dfd-to-uml-developer-handoff\/#breadcrumb\"},\"inLanguage\":\"pl-PL\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/dfd-vs-uml-when-to-use-each\/practical-implementation-patterns\/dfd-to-uml-developer-handoff\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/dfd-vs-uml-when-to-use-each\/practical-implementation-patterns\/dfd-to-uml-developer-handoff\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pl\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Data Flow Diagrams vs. UML: When to Use Each\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/dfd-vs-uml-when-to-use-each\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Practical Implementation Patterns\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/dfd-vs-uml-when-to-use-each\/practical-implementation-patterns\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Development Handoff: From DFD to UML Sequence\"}]},{\"@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":"DFD to UML Developer Handoff","description":"Master the functional spec to sequence diagram transition with traceability matrices and onboarding strategies for seamless developer handoff from DFD to UML.","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\/dfd-vs-uml-when-to-use-each\/practical-implementation-patterns\/dfd-to-uml-developer-handoff\/","og_locale":"pl_PL","og_type":"article","og_title":"DFD to UML Developer Handoff","og_description":"Master the functional spec to sequence diagram transition with traceability matrices and onboarding strategies for seamless developer handoff from DFD to UML.","og_url":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/dfd-vs-uml-when-to-use-each\/practical-implementation-patterns\/dfd-to-uml-developer-handoff\/","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\/dfd-vs-uml-when-to-use-each\/practical-implementation-patterns\/dfd-to-uml-developer-handoff\/","url":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/dfd-vs-uml-when-to-use-each\/practical-implementation-patterns\/dfd-to-uml-developer-handoff\/","name":"DFD to UML Developer Handoff","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/pl\/#website"},"datePublished":"2026-02-25T10:25:09+00:00","description":"Master the functional spec to sequence diagram transition with traceability matrices and onboarding strategies for seamless developer handoff from DFD to UML.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/dfd-vs-uml-when-to-use-each\/practical-implementation-patterns\/dfd-to-uml-developer-handoff\/#breadcrumb"},"inLanguage":"pl-PL","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/pl\/docs\/dfd-vs-uml-when-to-use-each\/practical-implementation-patterns\/dfd-to-uml-developer-handoff\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/dfd-vs-uml-when-to-use-each\/practical-implementation-patterns\/dfd-to-uml-developer-handoff\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/pl\/"},{"@type":"ListItem","position":2,"name":"Data Flow Diagrams vs. UML: When to Use Each","item":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/dfd-vs-uml-when-to-use-each\/"},{"@type":"ListItem","position":3,"name":"Practical Implementation Patterns","item":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/dfd-vs-uml-when-to-use-each\/practical-implementation-patterns\/"},{"@type":"ListItem","position":4,"name":"Development Handoff: From DFD to UML Sequence"}]},{"@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\/819","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\/819\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/docs\/816"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/media?parent=819"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/doc_tag?post=819"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}