{"id":1613,"date":"2026-02-25T10:43:52","date_gmt":"2026-02-25T10:43:52","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/sysml-essentials-for-beginners\/sysml-system-integration\/sysml-allocation-relationships-across-diagrams\/"},"modified":"2026-02-25T10:43:52","modified_gmt":"2026-02-25T10:43:52","slug":"sysml-allocation-relationships-across-diagrams","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/sysml-essentials-for-beginners\/sysml-system-integration\/sysml-allocation-relationships-across-diagrams\/","title":{"rendered":"Allocations and Relationships Across Diagrams"},"content":{"rendered":"

\u201cI just need to draw the diagrams and check off the boxes.\u201d That\u2019s what most newcomers say in their first week of SysML modeling \u2014 and it\u2019s the fastest path to a fragmented, inconsistent system model.<\/p>\n

But real systems aren\u2019t built from isolated diagrams. They emerge from the alignment of structure, behavior, and requirements through deliberate relationships. That\u2019s where SysML allocation comes in \u2014 not as a diagram, but as a foundational modeling concept that binds every layer of your system.<\/p>\n

After 20 years guiding teams through complex aerospace, medical device, and embedded software projects, I\u2019ve seen how missing allocation leads to untraceable design decisions, duplicated work, and costly rework. This chapter teaches you how to use SysML allocation correctly \u2014 not just to connect diagrams, but to ensure your model reflects real engineering intent.<\/p>\n

You\u2019ll learn how to map functions to components, link requirements to behaviors, and maintain consistency across the lifecycle \u2014 all through practical, real-world examples. If you\u2019re building a smart home controller, a drone flight system, or an autonomous vehicle, this is the backbone of model integrity.<\/p>\n

Understanding SysML Allocation<\/h2>\n

SysML allocation is the mechanism that connects elements across different diagram types \u2014 most commonly between functions (behavior), requirements (documented needs), and components (structure).<\/p>\n

It\u2019s not a standalone diagram. It\u2019s a modeling relationship \u2014 a kind of \u201ccontract\u201d that says: \u201cThis function is performed by this component\u201d or \u201cThis requirement is verified by this behavior.\u201d<\/p>\n

Without allocation, your model is a collection of isolated pieces. With it, you gain traceability, consistency, and a clear path from design intent to implementation.<\/p>\n

Why Allocation Is Often Misunderstood<\/h3>\n

Many beginners mistake allocation for simple linking or association. But in SysML, allocation is a formal stereotype: allocation<\/code> with specific source and target roles.<\/p>\n

It\u2019s not just about drawing a line. You must define what\u2019s being allocated, to where, and why. For example: \u201cThe control logic<\/em> function is allocated to the flight controller<\/em> component.\u201d That statement is the heart of functional allocation SysML.<\/p>\n

Overlooking this distinction leads to models that look correct but are structurally weak \u2014 especially when downstream testing or verification fails to find discrepancies.<\/p>\n

Allocation is not optional. It\u2019s the glue that holds your system model together.<\/p>\n

Types of SysML Allocation<\/h2>\n

There are three primary allocation patterns in SysML, each serving a distinct purpose in integration and traceability.<\/p>\n

1. Functional Allocation (Function \u2192 Component)<\/h3>\n

This is the most common form. It assigns a behavior (often a function or activity) to a physical component that performs it.<\/p>\n

For example: The motor control<\/em> activity is allocated to the actuator<\/em> component.<\/p>\n

This ensures that when you model behavior in an activity diagram, the responsible hardware or software component is clearly identified \u2014 no more \u201csomeone has to do this\u201d ambiguity.<\/p>\n

Use this when you want to answer: \u201cWho or what performs this action?\u201d<\/p>\n

2. Requirement Allocation (Requirement \u2192 Behavior or Component)<\/h3>\n

This links a system requirement to the behavior or component that satisfies it.<\/p>\n

For example: \u201cRequirement R101: The system must respond within 100ms\u201d is allocated to the response time analysis<\/em> activity.<\/p>\n

Why it matters: If a requirement isn\u2019t allocated, it risks being ignored in implementation. Allocation ensures full traceability \u2014 from stakeholder need to design verification.<\/p>\n

This is where SysML relationships become critical. Each allocation forms a traceable link that tools can audit and enforce.<\/p>\n

3. Structural Allocation (Component \u2192 Function or Requirement)<\/h3>\n

This form is less common but useful in reverse-engineering or analysis. It shows that a component enables or supports a function or requirement.<\/p>\n

For example: The power supply<\/em> component is allocated to support the system startup<\/em> function.<\/p>\n

Use this when you\u2019re analyzing dependencies: What parts of the system must be in place for a function to work?<\/p>\n

These three types are not mutually exclusive. A single component can be allocated to multiple functions, and a requirement can be verified by a combination of behaviors.<\/p>\n

How to Apply Allocation: A Step-by-Step Guide<\/h2>\n

Here\u2019s how I recommend you approach allocation in your own models \u2014 based on real-world engineering practice.<\/p>\n

    \n
  1. \n

    Define your system\u2019s key functions using activity or sequence diagrams.<\/p>\n<\/li>\n

  2. \n

    Model your system\u2019s components using block or internal block diagrams.<\/p>\n<\/li>\n

  3. \n

    Identify which component performs each function \u2014 not by guesswork, but by engineering design.<\/p>\n<\/li>\n

  4. \n

    Create allocation relationships from function to component.<\/p>\n<\/li>\n

  5. \n

    Link each requirement to the behavior or component that verifies it.<\/p>\n<\/li>\n

  6. \n

    Validate all allocations: Does every function have an owner? Does every requirement have a verification path?<\/p>\n<\/li>\n<\/ol>\n

    It\u2019s tempting to skip steps 4\u20136, but that\u2019s where models collapse under complexity. I\u2019ve seen teams lose entire verification cycles because a single requirement wasn\u2019t allocated to any behavior.<\/p>\n

    Allocation in Practice: Smart Home Controller Example<\/h3>\n

    Consider a smart door lock controller. Key functions:<\/p>\n

      \n
    • Authenticate user via PIN<\/li>\n
    • Unlock door motor<\/li>\n
    • Log access attempt<\/li>\n<\/ul>\n

      Components:<\/p>\n

        \n
      • Microcontroller (MCU)<\/li>\n
      • Keypad interface<\/li>\n
      • Motor driver<\/li>\n
      • Logging module<\/li>\n<\/ul>\n

        Now apply allocation:<\/p>\n

          \n
        • Authenticate user \u2192 MCU<\/li>\n
        • Unlock door motor \u2192 Motor driver<\/li>\n
        • Log access attempt \u2192 Logging module<\/li>\n<\/ul>\n

          Each function is now traceable to a component. If you later audit the system, you can confirm: \u201cDid the MCU handle authentication?\u201d \u201cWas the motor driver responsible for unlocking?\u201d<\/p>\n

          This is functional allocation SysML in action \u2014 not just a diagram, but a living model.<\/p>\n

          Best Practices for SysML Allocation<\/h2>\n

          Allocation isn\u2019t just about drawing lines. It\u2019s about modeling with purpose.<\/p>\n

            \n
          • \n

            Always justify allocations<\/strong>. Ask: \u201cWhy is this component responsible?\u201d Document design rationale in comments or constraints.<\/p>\n<\/li>\n

          • \n

            Use consistent naming<\/strong>. Don\u2019t mix \u201ccontrol logic\u201d and \u201ccontroller\u201d for the same thing \u2014 it breaks traceability.<\/p>\n<\/li>\n

          • \n

            Check for redundancy<\/strong>. Is a function allocated to multiple components? That may indicate design ambiguity.<\/p>\n<\/li>\n

          • \n

            Validate with stakeholders<\/strong>. Have your system engineers, testers, and requirements managers review allocations before finalizing.<\/p>\n<\/li>\n<\/ul>\n

            One of the most common mistakes? Assuming that because a function has a component in the same diagram, it\u2019s allocated. But without a formal allocation link, the model doesn\u2019t know the relationship exists.<\/p>\n

            Comparing SysML Relationships<\/h2>\n

            Understanding how allocation differs from other SysML relationships is essential for modeling clarity.<\/p>\n\n\n\n\n\n\n\n
            Relationship Type<\/th>\nDirection<\/th>\nPrimary Use<\/th>\nExample<\/th>\n<\/tr>\n
            SysML Allocation<\/td>\nFunction \u2192 Component<\/td>\nAssign behavior to responsible part<\/td>\nControl logic \u2192 MCU<\/td>\n<\/tr>\n
            Dependency<\/td>\nElement A \u2192 Element B<\/td>\nShow one element depends on another<\/td>\nCommunication \u2192 Network<\/td>\n<\/tr>\n
            Association<\/td>\nComponent \u2194 Component<\/td>\nPhysical connection or interface<\/td>\nKeypad \u2194 MCU<\/td>\n<\/tr>\n
            Traceability Link<\/td>\nRequirement \u2192 Behavior<\/td>\nLink requirement to verification method<\/td>\nR101 \u2192 Response time test<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

            Allocation is the only one that explicitly maps behavior to structure. While dependencies and associations describe connections, allocation explains responsibility.<\/p>\n

            Use allocation to answer: \u201cWho does what?\u201d Use dependency to answer: \u201cWhat does this rely on?\u201d Use association to ask: \u201cHow are components connected?\u201d<\/p>\n

            Confusing these leads to models that look correct but fail in real use.<\/p>\n

            Frequently Asked Questions<\/h2>\n

            Can I use SysML allocation to link a requirement to multiple components?<\/h3>\n

            Yes \u2014 if a requirement is satisfied through a combination of behaviors or components (e.g., \u201cThe system must be secure\u201d verified by firewall, encryption, and access control), you can allocate it to each relevant component or behavior.<\/p>\n

            But be cautious: over-allocating reduces clarity. If a requirement relies on multiple parts, consider creating a composite behavior that is allocated to a higher-level component.<\/p>\n

            Is allocation required in every SysML model?<\/h3>\n

            No, not technically. But in any serious system, especially safety-critical ones, allocation is non-negotiable for traceability and verification.<\/p>\n

            Even in small models, allocation forces you to think about responsibility \u2014 which is the essence of systems engineering.<\/p>\n

            How do I visualize allocation in Visual Paradigm?<\/h3>\n

            In Visual Paradigm, go to the Modeling<\/code> tab \u2192 Allocation<\/code> (a line with a small arrow pointing to a component). Drag from a function (e.g., activity or action) to a component.<\/p>\n

            It appears as a dashed line with a triangular arrowhead and a \u00aballocate\u00bb<\/code> stereotype.<\/p>\n

            Can I allocate a component to a requirement?<\/h3>\n

            Yes \u2014 this is structural allocation. It\u2019s valid when the component enables the requirement.<\/p>\n

            For example: \u201cThe system must run for 24 hours\u201d is allocated to the power supply<\/em> component because it enables sustained operation.<\/p>\n

            But ensure the role is clear: the component enables, not verifies, the requirement.<\/p>\n

            What\u2019s the difference between allocation and dependency?<\/h3>\n

            Allocation defines responsibility \u2014 \u201cthis behavior is performed by this component.\u201d<\/p>\n

            Dependency describes reliance \u2014 \u201cthis component depends on another to function.\u201d<\/p>\n

            For example: A display depends on a power supply (dependency), but the display controller allocates the \u201cshow status\u201d function (allocation).<\/p>\n

            How do I check if my model has all allocations?<\/h3>\n

            Use the Allocation Matrix<\/strong> report in your modeling tool. It shows all allocations, their source and target, and flags unallocated elements.<\/p>\n

            Manually verify: Can you trace every function to a component? Every requirement to a behavior? Fix any gaps before finalizing.<\/p>\n

            Remember: A model without proper SysML relationships is not a system model \u2014 it\u2019s a diagram collection.<\/p>\n

            With this knowledge, you\u2019re no longer just drawing diagrams. You\u2019re building a living, traceable system model \u2014 one that engineers can trust, verify, and evolve.<\/p>\n

            Next, we\u2019ll explore how to maintain this traceability across the entire system lifecycle \u2014 because a good model isn\u2019t just built, it\u2019s sustained.<\/p>\n","protected":false},"excerpt":{"rendered":"

            \u201cI just need to draw the diagrams and check off the boxes.\u201d That\u2019s what most newcomers say in their first week of SysML modeling \u2014 and it\u2019s the fastest path to a fragmented, inconsistent system model. But real systems aren\u2019t built from isolated diagrams. They emerge from the alignment of structure, behavior, and requirements through […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":1611,"menu_order":1,"template":"","meta":{"_acf_changed":false,"inline_featured_image":false,"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"doc_tag":[],"class_list":["post-1613","docs","type-docs","status-publish","hentry"],"acf":[],"yoast_head":"\nSysML Allocation: Mastering Relationships Across Diagrams<\/title>\n<meta name=\"description\" content=\"Learn how SysML allocation integrates functions, requirements, and components across diagrams. Master functional allocation SysML and SysML relationships for robust system design and traceability.\" \/>\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\/sysml-essentials-for-beginners\/sysml-system-integration\/sysml-allocation-relationships-across-diagrams\/\" \/>\n<meta property=\"og:locale\" content=\"pl_PL\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"SysML Allocation: Mastering Relationships Across Diagrams\" \/>\n<meta property=\"og:description\" content=\"Learn how SysML allocation integrates functions, requirements, and components across diagrams. Master functional allocation SysML and SysML relationships for robust system design and traceability.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/sysml-essentials-for-beginners\/sysml-system-integration\/sysml-allocation-relationships-across-diagrams\/\" \/>\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=\"8 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\/sysml-essentials-for-beginners\/sysml-system-integration\/sysml-allocation-relationships-across-diagrams\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/sysml-essentials-for-beginners\/sysml-system-integration\/sysml-allocation-relationships-across-diagrams\/\",\"name\":\"SysML Allocation: Mastering Relationships Across Diagrams\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/#website\"},\"datePublished\":\"2026-02-25T10:43:52+00:00\",\"description\":\"Learn how SysML allocation integrates functions, requirements, and components across diagrams. Master functional allocation SysML and SysML relationships for robust system design and traceability.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/sysml-essentials-for-beginners\/sysml-system-integration\/sysml-allocation-relationships-across-diagrams\/#breadcrumb\"},\"inLanguage\":\"pl-PL\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/sysml-essentials-for-beginners\/sysml-system-integration\/sysml-allocation-relationships-across-diagrams\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/sysml-essentials-for-beginners\/sysml-system-integration\/sysml-allocation-relationships-across-diagrams\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pl\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"SysML Essentials for Beginners\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/sysml-essentials-for-beginners\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Building and Integrating a Complete System Model\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/sysml-essentials-for-beginners\/sysml-system-integration\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Allocations and Relationships Across Diagrams\"}]},{\"@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":"SysML Allocation: Mastering Relationships Across Diagrams","description":"Learn how SysML allocation integrates functions, requirements, and components across diagrams. Master functional allocation SysML and SysML relationships for robust system design and traceability.","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\/sysml-essentials-for-beginners\/sysml-system-integration\/sysml-allocation-relationships-across-diagrams\/","og_locale":"pl_PL","og_type":"article","og_title":"SysML Allocation: Mastering Relationships Across Diagrams","og_description":"Learn how SysML allocation integrates functions, requirements, and components across diagrams. Master functional allocation SysML and SysML relationships for robust system design and traceability.","og_url":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/sysml-essentials-for-beginners\/sysml-system-integration\/sysml-allocation-relationships-across-diagrams\/","og_site_name":"Visual Paradigm Skills Polski","twitter_card":"summary_large_image","twitter_misc":{"Szacowany czas czytania":"8 minut"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/sysml-essentials-for-beginners\/sysml-system-integration\/sysml-allocation-relationships-across-diagrams\/","url":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/sysml-essentials-for-beginners\/sysml-system-integration\/sysml-allocation-relationships-across-diagrams\/","name":"SysML Allocation: Mastering Relationships Across Diagrams","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/pl\/#website"},"datePublished":"2026-02-25T10:43:52+00:00","description":"Learn how SysML allocation integrates functions, requirements, and components across diagrams. Master functional allocation SysML and SysML relationships for robust system design and traceability.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/sysml-essentials-for-beginners\/sysml-system-integration\/sysml-allocation-relationships-across-diagrams\/#breadcrumb"},"inLanguage":"pl-PL","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/pl\/docs\/sysml-essentials-for-beginners\/sysml-system-integration\/sysml-allocation-relationships-across-diagrams\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/sysml-essentials-for-beginners\/sysml-system-integration\/sysml-allocation-relationships-across-diagrams\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/pl\/"},{"@type":"ListItem","position":2,"name":"SysML Essentials for Beginners","item":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/sysml-essentials-for-beginners\/"},{"@type":"ListItem","position":3,"name":"Building and Integrating a Complete System Model","item":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/sysml-essentials-for-beginners\/sysml-system-integration\/"},{"@type":"ListItem","position":4,"name":"Allocations and Relationships Across Diagrams"}]},{"@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\/1613","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\/1613\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/docs\/1611"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/media?parent=1613"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/doc_tag?post=1613"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}