{"id":1407,"date":"2026-02-25T10:40:55","date_gmt":"2026-02-25T10:40:55","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/de\/docs\/real-world-uml-case-studies-software-design\/enhancing-uml-with-visual-paradigm-tools\/uml-team-collaboration-version-control\/"},"modified":"2026-02-25T10:40:55","modified_gmt":"2026-02-25T10:40:55","slug":"uml-team-collaboration-version-control","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/de\/docs\/real-world-uml-case-studies-software-design\/enhancing-uml-with-visual-paradigm-tools\/uml-team-collaboration-version-control\/","title":{"rendered":"Version Control and Teamwork in UML Projects"},"content":{"rendered":"<p>When a team stops arguing over diagram versions and starts converging on a shared understanding, you know they\u2019ve moved from theory to practice. That moment\u2014when the team can inspect, review, and evolve a model without losing context\u2014marks a shift from isolated sketching to true collaborative modeling.<\/p>\n<p>It\u2019s not about perfection. It\u2019s about consistency, traceability, and the ability to refactor without fear. In my 20 years of guiding teams through complex enterprise systems, I\u2019ve rarely seen a project succeed without a solid foundation in version control UML and structured team workflows.<\/p>\n<p>This chapter cuts through the noise. You\u2019ll learn how Visual Paradigm\u2019s Team Collaboration Server transforms UML from a static artifact into a living, evolving blueprint\u2014enabling multiple engineers, architects, and stakeholders to contribute with confidence. You\u2019ll walk through branching strategies, merge conflict resolution, and real-world patterns that prevent misalignment.<\/p>\n<h2>Why Version Control UML Matters in Real Teams<\/h2>\n<p>Imagine a team of five engineers, each responsible for a component of a financial system. One drafts the payment processing sequence diagram. Another adds a class diagram for transaction logging. Without version control, those diagrams become disconnected fragments\u2014each person\u2019s version irreconcilable, leading to duplicated work and misaligned logic.<\/p>\n<p>Version control UML is not about saving files. It\u2019s about managing change at the semantic level\u2014tracking who modified what, when, and why. It\u2019s the difference between a shared document and a shared design.<\/p>\n<p>Visual Paradigm\u2019s Team Collaboration Server integrates directly with your UML model, treating each diagram as a versioned entity. Every change is logged, every contributor credited, and every merge path documented.<\/p>\n<ul>\n<li><strong>Traceability:<\/strong> Changes to a class diagram can be linked to user stories or defect reports.<\/li>\n<li><strong>Conflict detection:<\/strong> When two people edit the same class, the system highlights the divergence.<\/li>\n<li><strong>Rollback capability:<\/strong> If a refactor breaks the design, you can revert to a known-good state.<\/li>\n<\/ul>\n<h2>Branching Strategies for UML Models<\/h2>\n<p>Just like code, UML models benefit from branching. But the rules aren\u2019t one-size-fits-all. The key is to align branching with your development workflow.<\/p>\n<h3>Feature Branching: For Feature-Driven Design<\/h3>\n<p>When a new feature\u2014say, multi-factor authentication in a banking app\u2014requires changes across multiple diagrams, create a dedicated branch.<\/p>\n<p>Start by branching off the main model. Add new classes, modify sequence diagrams, and update state machines. This isolates the work and prevents premature integration.<\/p>\n<p>Once validated through peer review and automated checks, merge the branch. The model evolves without disrupting the baseline.<\/p>\n<h3>Release Branching: For Stable Model Snapshots<\/h3>\n<p>Before a release, create a release branch. This preserves a consistent model state for documentation, audits, and stakeholder review.<\/p>\n<p>Hotfixes\u2014critical bugs in a payment flow\u2014can be addressed in a hotfix branch. After review and approval, merge into both the release and main branches.<\/p>\n<p>Release branches are especially useful when you need to generate documentation or generate code from a stable model.<\/p>\n<h3>Trunk-Based Modeling: For Small, Agile Teams<\/h3>\n<p>Smaller teams with strong communication can use trunk-based development. All changes go directly into the main branch, but only after peer review.<\/p>\n<p>It\u2019s fast, but only if you have a culture of regular, lightweight reviews. I\u2019ve seen teams lose context here when reviews are skipped. Always enforce pre-commit checks.<\/p>\n<h2>Collaborative Modeling: How Teams Actually Work Together<\/h2>\n<p>Collaborative modeling isn\u2019t about everyone drawing at once. It\u2019s about building a shared mental model through structured contributions.<\/p>\n<p>Here\u2019s how successful teams use UML team collaboration:<\/p>\n<ol>\n<li><strong>Assign ownership:<\/strong> A lead architect owns the system architecture diagram. A domain expert owns the class diagram for user management.<\/li>\n<li><strong>Set guidelines:<\/strong> Define naming conventions, diagram depth, and abstraction levels to maintain consistency.<\/li>\n<li><strong>Enforce peer review:<\/strong> Every significant change must be reviewed by at least one other team member before merging.<\/li>\n<li><strong>Automate validation:<\/strong> Use Visual Paradigm\u2019s built-in checks to detect missing associations, inconsistent lifelines, or invalid state transitions.<\/li>\n<\/ol>\n<p>It\u2019s not uncommon for a class diagram to go through three or four revisions before it stabilizes. But each iteration refines the model, not the work.<\/p>\n<h3>Real-World Example: Hospital Management System<\/h3>\n<p>In a recent project, a team modeled a patient discharge workflow. The initial sequence diagram showed a single, linear path. After review, a junior developer suggested a branch for emergency discharges.<\/p>\n<p>This led to a state diagram to represent all possible discharge states\u2014\u201cplanned,\u201d \u201cemergency,\u201d \u201cdelayed,\u201d \u201ccancelled.\u201d The model evolved through collaborative input, with each change logged and reviewed.<\/p>\n<p>Without version control UML, that evolution would have been lost in email threads and conflicting versions.<\/p>\n<h2>Managing Merges and Resolving Conflicts<\/h2>\n<p>Merges in UML are not as simple as in code. Two people might edit the same class without realizing it. One adds a method. The other changes the inheritance hierarchy.<\/p>\n<p>Visual Paradigm detects such conflicts and presents a side-by-side comparison. You can choose which change to keep, merge selectively, or reconcile manually.<\/p>\n<p>Here\u2019s how to handle common merge scenarios:<\/p>\n<table>\n<tbody>\n<tr>\n<th>Conflict Type<\/th>\n<th>Recommended Action<\/th>\n<\/tr>\n<tr>\n<td>Same class, different attributes<\/td>\n<td>Merge both sets. Resolve naming conflicts.<\/td>\n<\/tr>\n<tr>\n<td>Same class, conflicting inheritance<\/td>\n<td>Re-evaluate the domain model. Discuss in team sync.<\/td>\n<\/tr>\n<tr>\n<td>Sequence diagrams: different message order<\/td>\n<td>Reconstruct the correct order based on business logic.<\/td>\n<\/tr>\n<tr>\n<td>Use case diagram: duplicate use cases<\/td>\n<td>Consolidate. Add actor roles where needed.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Always merge with intention. The goal is not to preserve every line of change\u2014but to preserve the shared understanding.<\/p>\n<h2>Best Practices for Sustainable UML Team Collaboration<\/h2>\n<p>These are the habits I\u2019ve seen successful teams adopt:<\/p>\n<ul>\n<li><strong>Review every model change:<\/strong> Even small edits. A missing note can mislead.<\/li>\n<li><strong>Use commit messages that explain intent:<\/strong> \u201cAdd error handling to transaction state machine\u201d is better than \u201cFixed bug.\u201d<\/li>\n<li><strong>Tag models by release:<\/strong> Makes it easy to generate documentation for a specific version.<\/li>\n<li><strong>Document model evolution:<\/strong> A changelog of major model updates helps new team members onboard quickly.<\/li>\n<\/ul>\n<p>Version control UML isn\u2019t a luxury. It\u2019s a necessity for teams building systems where design integrity directly impacts reliability and maintainability.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>How does Visual Paradigm handle UML model versioning?<\/h3>\n<p>It uses Git-based repositories under the hood. Each model is stored as a project folder with .uml files tracked in version control. You can view history, compare versions, and merge directly from the UI.<\/p>\n<h3>Can multiple people edit the same diagram at once?<\/h3>\n<p>Not simultaneously. Visual Paradigm locks diagrams during edit to prevent overwrites. However, multiple people can work on different diagrams at the same time. Use branches to isolate feature work.<\/p>\n<h3>What\u2019s the best way to integrate UML team collaboration with CI\/CD?<\/h3>\n<p>Set up a pre-build check that validates model consistency. Use Visual Paradigm\u2019s export features to generate documentation or code. If the model fails validation, block the build.<\/p>\n<h3>How do I ensure new team members understand the model history?<\/h3>\n<p>Enable model change logs. Encourage detailed commit messages. Use the built-in \u201cblame\u201d feature to see who changed what and when. Pair new hires with senior members for onboarding.<\/p>\n<h3>Is it safe to merge a feature branch into main if it breaks a rule?<\/h3>\n<p>No. Automated validation should block merges that introduce errors. Always run a full model check before merging. It\u2019s better to fail early than to ship a flawed design.<\/p>\n<h3>How often should we review UML diagrams in a team?<\/h3>\n<p>At least once per sprint. Review for completeness, consistency, and alignment with requirements. Use the review as a chance to refine the model\u2014don\u2019t just approve.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>When a team stops arguing over diagram versions and starts converging on a shared understanding, you know they\u2019ve moved from theory to practice. That moment\u2014when the team can inspect, review, and evolve a model without losing context\u2014marks a shift from isolated sketching to true collaborative modeling. It\u2019s not about perfection. It\u2019s about consistency, traceability, and [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":1404,"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-1407","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 Team Collaboration: Mastering Version Control &amp; Modeling<\/title>\n<meta name=\"description\" content=\"Master collaborative modeling with version control UML. Learn how Visual Paradigm\u2019s Team Collaboration Server enables seamless UML team collaboration for real-world software design.\" \/>\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\/de\/docs\/real-world-uml-case-studies-software-design\/enhancing-uml-with-visual-paradigm-tools\/uml-team-collaboration-version-control\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"UML Team Collaboration: Mastering Version Control &amp; Modeling\" \/>\n<meta property=\"og:description\" content=\"Master collaborative modeling with version control UML. Learn how Visual Paradigm\u2019s Team Collaboration Server enables seamless UML team collaboration for real-world software design.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/de\/docs\/real-world-uml-case-studies-software-design\/enhancing-uml-with-visual-paradigm-tools\/uml-team-collaboration-version-control\/\" \/>\n<meta property=\"og:site_name\" content=\"Visual Paradigm Skills Deutsch\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data1\" content=\"6\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/docs\/real-world-uml-case-studies-software-design\/enhancing-uml-with-visual-paradigm-tools\/uml-team-collaboration-version-control\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/de\/docs\/real-world-uml-case-studies-software-design\/enhancing-uml-with-visual-paradigm-tools\/uml-team-collaboration-version-control\/\",\"name\":\"UML Team Collaboration: Mastering Version Control & Modeling\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/#website\"},\"datePublished\":\"2026-02-25T10:40:55+00:00\",\"description\":\"Master collaborative modeling with version control UML. Learn how Visual Paradigm\u2019s Team Collaboration Server enables seamless UML team collaboration for real-world software design.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/docs\/real-world-uml-case-studies-software-design\/enhancing-uml-with-visual-paradigm-tools\/uml-team-collaboration-version-control\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/de\/docs\/real-world-uml-case-studies-software-design\/enhancing-uml-with-visual-paradigm-tools\/uml-team-collaboration-version-control\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/docs\/real-world-uml-case-studies-software-design\/enhancing-uml-with-visual-paradigm-tools\/uml-team-collaboration-version-control\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/de\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Real-World UML: Case Studies in Software Design\",\"item\":\"https:\/\/skills.visual-paradigm.com\/de\/docs\/real-world-uml-case-studies-software-design\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Enhancing UML with Visual Paradigm Tools\",\"item\":\"https:\/\/skills.visual-paradigm.com\/de\/docs\/real-world-uml-case-studies-software-design\/enhancing-uml-with-visual-paradigm-tools\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Version Control and Teamwork in UML Projects\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/#website\",\"url\":\"https:\/\/skills.visual-paradigm.com\/de\/\",\"name\":\"Visual Paradigm Skills Deutsch\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/skills.visual-paradigm.com\/de\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/#organization\",\"name\":\"Visual Paradigm Skills Deutsch\",\"url\":\"https:\/\/skills.visual-paradigm.com\/de\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/de\/wp-content\/uploads\/sites\/4\/2026\/02\/favicon.svg\",\"contentUrl\":\"https:\/\/skills.visual-paradigm.com\/de\/wp-content\/uploads\/sites\/4\/2026\/02\/favicon.svg\",\"width\":70,\"height\":70,\"caption\":\"Visual Paradigm Skills Deutsch\"},\"image\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"UML Team Collaboration: Mastering Version Control & Modeling","description":"Master collaborative modeling with version control UML. Learn how Visual Paradigm\u2019s Team Collaboration Server enables seamless UML team collaboration for real-world software design.","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\/de\/docs\/real-world-uml-case-studies-software-design\/enhancing-uml-with-visual-paradigm-tools\/uml-team-collaboration-version-control\/","og_locale":"de_DE","og_type":"article","og_title":"UML Team Collaboration: Mastering Version Control & Modeling","og_description":"Master collaborative modeling with version control UML. Learn how Visual Paradigm\u2019s Team Collaboration Server enables seamless UML team collaboration for real-world software design.","og_url":"https:\/\/skills.visual-paradigm.com\/de\/docs\/real-world-uml-case-studies-software-design\/enhancing-uml-with-visual-paradigm-tools\/uml-team-collaboration-version-control\/","og_site_name":"Visual Paradigm Skills Deutsch","twitter_card":"summary_large_image","twitter_misc":{"Gesch\u00e4tzte Lesezeit":"6\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/skills.visual-paradigm.com\/de\/docs\/real-world-uml-case-studies-software-design\/enhancing-uml-with-visual-paradigm-tools\/uml-team-collaboration-version-control\/","url":"https:\/\/skills.visual-paradigm.com\/de\/docs\/real-world-uml-case-studies-software-design\/enhancing-uml-with-visual-paradigm-tools\/uml-team-collaboration-version-control\/","name":"UML Team Collaboration: Mastering Version Control & Modeling","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/de\/#website"},"datePublished":"2026-02-25T10:40:55+00:00","description":"Master collaborative modeling with version control UML. Learn how Visual Paradigm\u2019s Team Collaboration Server enables seamless UML team collaboration for real-world software design.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/de\/docs\/real-world-uml-case-studies-software-design\/enhancing-uml-with-visual-paradigm-tools\/uml-team-collaboration-version-control\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/de\/docs\/real-world-uml-case-studies-software-design\/enhancing-uml-with-visual-paradigm-tools\/uml-team-collaboration-version-control\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/de\/docs\/real-world-uml-case-studies-software-design\/enhancing-uml-with-visual-paradigm-tools\/uml-team-collaboration-version-control\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/de\/"},{"@type":"ListItem","position":2,"name":"Real-World UML: Case Studies in Software Design","item":"https:\/\/skills.visual-paradigm.com\/de\/docs\/real-world-uml-case-studies-software-design\/"},{"@type":"ListItem","position":3,"name":"Enhancing UML with Visual Paradigm Tools","item":"https:\/\/skills.visual-paradigm.com\/de\/docs\/real-world-uml-case-studies-software-design\/enhancing-uml-with-visual-paradigm-tools\/"},{"@type":"ListItem","position":4,"name":"Version Control and Teamwork in UML Projects"}]},{"@type":"WebSite","@id":"https:\/\/skills.visual-paradigm.com\/de\/#website","url":"https:\/\/skills.visual-paradigm.com\/de\/","name":"Visual Paradigm Skills Deutsch","description":"","publisher":{"@id":"https:\/\/skills.visual-paradigm.com\/de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/skills.visual-paradigm.com\/de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/skills.visual-paradigm.com\/de\/#organization","name":"Visual Paradigm Skills Deutsch","url":"https:\/\/skills.visual-paradigm.com\/de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/skills.visual-paradigm.com\/de\/#\/schema\/logo\/image\/","url":"https:\/\/skills.visual-paradigm.com\/de\/wp-content\/uploads\/sites\/4\/2026\/02\/favicon.svg","contentUrl":"https:\/\/skills.visual-paradigm.com\/de\/wp-content\/uploads\/sites\/4\/2026\/02\/favicon.svg","width":70,"height":70,"caption":"Visual Paradigm Skills Deutsch"},"image":{"@id":"https:\/\/skills.visual-paradigm.com\/de\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/docs\/1407","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/docs"}],"about":[{"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/types\/docs"}],"author":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/docs\/1407\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/docs\/1404"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/media?parent=1407"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/doc_tag?post=1407"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}