{"id":1711,"date":"2026-02-25T10:44:59","date_gmt":"2026-02-25T10:44:59","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/de\/docs\/uml-basics-diagrams-for-beginners\/uml-best-practices\/scaling-uml-models\/"},"modified":"2026-02-25T10:44:59","modified_gmt":"2026-02-25T10:44:59","slug":"scaling-uml-models","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/de\/docs\/uml-basics-diagrams-for-beginners\/uml-best-practices\/scaling-uml-models\/","title":{"rendered":"Scaling UML from Simple to Complex Projects"},"content":{"rendered":"<p>Many beginners start with a single class or use case diagram and assume that\u2019s all they\u2019ll ever need. But real software projects demand more than isolated sketches. Your model must grow\u2014not just in size, but in clarity, coherence, and purpose. The challenge isn\u2019t just drawing more elements. It\u2019s about knowing when and how to evolve your UML diagrams as your system grows. I\u2019ve seen teams stall because their diagrams became tangled, outdated, or irrelevant to the code.<\/p>\n<p>Scaling UML models isn\u2019t about adding complexity for its own sake. It\u2019s about creating a shared language that evolves with your project. The goal is to keep your models actionable, maintainable, and aligned with both business needs and technical implementation.<\/p>\n<p>Here, you\u2019ll learn how to grow UML from beginner stages into a robust, maintainable system model. You\u2019ll understand when to expand, when to simplify, and how to use tools like Visual Paradigm to support iterative growth. This is not theory\u2014it\u2019s what works in real agile environments.<\/p>\n<h2>From Isolated Diagrams to a Coherent Model<\/h2>\n<p>Beginner projects often use isolated diagrams: a single class diagram for the core model, a use case for requirements. But in larger projects, these diagrams must connect. A use case should lead to a sequence diagram. A class diagram should reflect the structure used in activity and state machines.<\/p>\n<p>When you evolve UML diagrams, the key is traceability. Every use case must be tied to a sequence or activity diagram. Every class should appear in at least one interaction diagram. This isn\u2019t bureaucracy\u2014it\u2019s a way to ensure that your design remains coherent across layers.<\/p>\n<ul>\n<li>Start with one diagram type (e.g., use case) and build outward.<\/li>\n<li>Link diagrams with clear naming and traceability markers.<\/li>\n<li>Use package diagrams to organize related model elements.<\/li>\n<\/ul>\n<p>Without this structure, your diagrams become islands. Once you start connecting them, you\u2019re not just modeling\u2014it\u2019s communicating intent.<\/p>\n<h3>Use Case to Sequence: A Natural Evolution<\/h3>\n<p>When you begin, use case diagrams help capture functional requirements. But they don\u2019t show behavior over time. That\u2019s where sequence diagrams come in.<\/p>\n<p>Take a simple login process: the use case \u201cAuthenticate User\u201d becomes a sequence diagram with User, Authentication Service, and Database. You\u2019ll see message flows, activation bars, and conditional paths.<\/p>\n<p>This evolution isn\u2019t optional. It\u2019s how you validate that your design handles real-world timing, error states, and concurrency. The sequence diagram reveals what the class diagram hides.<\/p>\n<p>Use case \u2192 sequence is the most reliable path to evolving UML diagrams for developers and stakeholders alike.<\/p>\n<h2>Evolve, Don\u2019t Over-Model: The Right Balance<\/h2>\n<p>Scaling UML models doesn\u2019t mean making every diagram as detailed as possible. It means making them relevant. Too much detail kills clarity. Too little leaves gaps in understanding.<\/p>\n<p>I\u2019ve worked on projects where the class diagram had 200+ classes. No one could read it. The solution wasn\u2019t to remove elements\u2014it was to organize them with packages and dependencies.<\/p>\n<p>Use packages to group related classes: <code>payment<\/code>, <code>user<\/code>, <code>order<\/code>. Then, use dependency arrows to show how they interact. This keeps your model modular and readable.<\/p>\n<table>\n<tbody>\n<tr>\n<th>When to Evolve<\/th>\n<th>When to Simplify<\/th>\n<\/tr>\n<tr>\n<td>Adding new functionality<\/td>\n<td>Overlapping or redundant diagrams<\/td>\n<\/tr>\n<tr>\n<td>Team grows beyond 3 people<\/td>\n<td>Diagram has more than 15\u201320 lifelines<\/td>\n<\/tr>\n<tr>\n<td>Codebase shows structural changes<\/td>\n<td>Stakeholders can\u2019t follow the logic<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>These aren\u2019t rigid rules. They\u2019re guiding principles. The real test? Can your team explain the model in a 5-minute meeting? If not, it\u2019s too complex.<\/p>\n<h3>Visual Paradigm: Your Agile Partner in Scaling<\/h3>\n<p>Tools like Visual Paradigm help you scale UML models without adding friction. You can generate class diagrams from code, synchronize diagrams across versions, and even use AI to suggest improvements.<\/p>\n<p>When you evolve UML diagrams, use features like:<\/p>\n<ul>\n<li><strong>Model versioning<\/strong> to track changes across sprints.<\/li>\n<li><strong>Diagram linking<\/strong> to create traceability between use cases and sequences.<\/li>\n<li><strong>AI-powered refactoring<\/strong> to detect redundant relationships or missing associations.<\/li>\n<\/ul>\n<p>These features don\u2019t replace good design\u2014they support it. They let you focus on intent, not syntax.<\/p>\n<h2>Strategies for Scaling UML in Larger Projects<\/h2>\n<p>UML for larger projects isn\u2019t about doing more\u2014it\u2019s about doing it smarter. Here\u2019s how to grow UML from beginner models into a scalable, maintainable system.<\/p>\n<h3>1. Start Small, Expand Gradually<\/h3>\n<p>Don\u2019t try to model the entire system at once. Begin with core use cases. Draw the sequence for the most critical path. Then, expand.<\/p>\n<p>For example: in a shopping app, start with \u201cPlace Order.\u201d Once that\u2019s clear, add \u201cCancel Order,\u201d \u201cApply Discount,\u201d and \u201cProcess Refund.\u201d Each new feature gets a new sequence and class additions.<\/p>\n<p>This incremental approach keeps your model aligned with development sprints.<\/p>\n<h3>2. Use Swimlanes for Responsibility Mapping<\/h3>\n<p>Activity diagrams often involve multiple roles: User, System, Payment Gateway. Use swimlanes to assign actions to actors.<\/p>\n<p>This doesn\u2019t just improve readability. It makes it easier to assign tasks in agile workflows and track ownership.<\/p>\n<h3>3. Integrate with Agile Practices<\/h3>\n<p>UML isn\u2019t outdated in agile. It\u2019s a planning tool. Use use case diagrams to prioritize backlog items. Turn sequences into acceptance criteria. Use class diagrams to guide architecture decisions.<\/p>\n<p>Evolve UML diagrams with the sprint. Update them after each iteration. Keep them in sync with code.<\/p>\n<h3>4. Maintain a Living Model<\/h3>\n<p>A good UML model isn\u2019t a one-time artifact. It\u2019s a living document.<\/p>\n<p>Update it when:<\/p>\n<ul>\n<li>Requirements change.<\/li>\n<li>You refactor code.<\/li>\n<li>Stakeholders ask clarifying questions.<\/li>\n<\/ul>\n<p>Treat your diagrams as part of the codebase. Version them. Review them. Refactor them.<\/p>\n<h2>Common Pitfalls in Scaling UML<\/h2>\n<p>Even experienced teams stumble when growing UML models. Here\u2019s what to avoid:<\/p>\n<ul>\n<li><strong>Adding every class too early<\/strong> \u2013 Only model what matters to the current feature.<\/li>\n<li><strong>Creating overly detailed sequences<\/strong> \u2013 Focus on the core path. Use fragments for alternatives.<\/li>\n<li><strong>Using inconsistent notation<\/strong> \u2013 Stick to standard UML symbols. Avoid custom shapes.<\/li>\n<li><strong>Isolating diagrams<\/strong> \u2013 Ensure use cases link to sequences, classes to activities.<\/li>\n<\/ul>\n<p>These mistakes are easy to fix\u2014but only if you know they exist. Make it a habit to review your diagrams at the end of each sprint.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>How do I grow UML from beginner to advanced levels?<\/h3>\n<p>Start with one diagram type\u2014use case, class, or sequence. As your project grows, add supporting diagrams. Use packages to organize, traceability to link. Focus on clarity over completeness. Let the model grow with your understanding.<\/p>\n<h3>Can I use UML for larger projects without overwhelming my team?<\/h3>\n<p>Absolutely. The key is to keep it lightweight. Use high-level diagrams for planning. Dive into details only when needed. Use tools that support collaboration and versioning. UML is not a burden\u2014it\u2019s a shared language.<\/p>\n<h3>How do I evolve UML diagrams as my project grows?<\/h3>\n<p>Begin with core elements. Add complexity incrementally. Use packages to group related elements. Link diagrams (use case \u2192 sequence, class \u2192 activity). Review and refactor after each sprint.<\/p>\n<h3>Should I model everything in UML, even if it\u2019s not critical?<\/h3>\n<p>No. Only model what helps communication or design. Focus on high-impact areas\u2014core logic, complex interactions, new features. Avoid modeling simple getters\/setters or trivial classes.<\/p>\n<h3>What tools help scale UML models effectively?<\/h3>\n<p>Visual Paradigm excels here. It supports model versioning, AI-driven suggestions, and seamless integration with agile workflows. It also enables cross-diagram traceability, which is key for scaling UML models.<\/p>\n<h3>How often should I update my UML diagrams during a sprint?<\/h3>\n<p>Review and update at the end of each sprint. If a major change occurs mid-sprint (e.g., a new requirement), update the relevant diagrams immediately. Keep them in sync with code and decisions.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Many beginners start with a single class or use case diagram and assume that\u2019s all they\u2019ll ever need. But real software projects demand more than isolated sketches. Your model must grow\u2014not just in size, but in clarity, coherence, and purpose. The challenge isn\u2019t just drawing more elements. It\u2019s about knowing when and how to evolve [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":1707,"menu_order":3,"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-1711","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>Scaling UML Models: From Simple to Complex<\/title>\n<meta name=\"description\" content=\"Learn how to grow UML from beginner models to scalable diagrams for larger projects. Master evolving UML diagrams with practical strategies, tools, and real-world patterns.\" \/>\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\/uml-basics-diagrams-for-beginners\/uml-best-practices\/scaling-uml-models\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Scaling UML Models: From Simple to Complex\" \/>\n<meta property=\"og:description\" content=\"Learn how to grow UML from beginner models to scalable diagrams for larger projects. Master evolving UML diagrams with practical strategies, tools, and real-world patterns.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/de\/docs\/uml-basics-diagrams-for-beginners\/uml-best-practices\/scaling-uml-models\/\" \/>\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\/uml-basics-diagrams-for-beginners\/uml-best-practices\/scaling-uml-models\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/de\/docs\/uml-basics-diagrams-for-beginners\/uml-best-practices\/scaling-uml-models\/\",\"name\":\"Scaling UML Models: From Simple to Complex\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/#website\"},\"datePublished\":\"2026-02-25T10:44:59+00:00\",\"description\":\"Learn how to grow UML from beginner models to scalable diagrams for larger projects. Master evolving UML diagrams with practical strategies, tools, and real-world patterns.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/docs\/uml-basics-diagrams-for-beginners\/uml-best-practices\/scaling-uml-models\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/de\/docs\/uml-basics-diagrams-for-beginners\/uml-best-practices\/scaling-uml-models\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/de\/docs\/uml-basics-diagrams-for-beginners\/uml-best-practices\/scaling-uml-models\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/de\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"UML Basics: Diagrams for Beginners\",\"item\":\"https:\/\/skills.visual-paradigm.com\/de\/docs\/uml-basics-diagrams-for-beginners\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Best Practices and Common Pitfalls\",\"item\":\"https:\/\/skills.visual-paradigm.com\/de\/docs\/uml-basics-diagrams-for-beginners\/uml-best-practices\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Scaling UML from Simple to Complex 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":"Scaling UML Models: From Simple to Complex","description":"Learn how to grow UML from beginner models to scalable diagrams for larger projects. Master evolving UML diagrams with practical strategies, tools, and real-world patterns.","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\/uml-basics-diagrams-for-beginners\/uml-best-practices\/scaling-uml-models\/","og_locale":"de_DE","og_type":"article","og_title":"Scaling UML Models: From Simple to Complex","og_description":"Learn how to grow UML from beginner models to scalable diagrams for larger projects. Master evolving UML diagrams with practical strategies, tools, and real-world patterns.","og_url":"https:\/\/skills.visual-paradigm.com\/de\/docs\/uml-basics-diagrams-for-beginners\/uml-best-practices\/scaling-uml-models\/","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\/uml-basics-diagrams-for-beginners\/uml-best-practices\/scaling-uml-models\/","url":"https:\/\/skills.visual-paradigm.com\/de\/docs\/uml-basics-diagrams-for-beginners\/uml-best-practices\/scaling-uml-models\/","name":"Scaling UML Models: From Simple to Complex","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/de\/#website"},"datePublished":"2026-02-25T10:44:59+00:00","description":"Learn how to grow UML from beginner models to scalable diagrams for larger projects. Master evolving UML diagrams with practical strategies, tools, and real-world patterns.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/de\/docs\/uml-basics-diagrams-for-beginners\/uml-best-practices\/scaling-uml-models\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/de\/docs\/uml-basics-diagrams-for-beginners\/uml-best-practices\/scaling-uml-models\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/de\/docs\/uml-basics-diagrams-for-beginners\/uml-best-practices\/scaling-uml-models\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/de\/"},{"@type":"ListItem","position":2,"name":"UML Basics: Diagrams for Beginners","item":"https:\/\/skills.visual-paradigm.com\/de\/docs\/uml-basics-diagrams-for-beginners\/"},{"@type":"ListItem","position":3,"name":"Best Practices and Common Pitfalls","item":"https:\/\/skills.visual-paradigm.com\/de\/docs\/uml-basics-diagrams-for-beginners\/uml-best-practices\/"},{"@type":"ListItem","position":4,"name":"Scaling UML from Simple to Complex 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\/1711","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\/1711\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/docs\/1707"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/media?parent=1711"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/de\/wp-json\/wp\/v2\/doc_tag?post=1711"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}