{"id":798,"date":"2026-02-25T10:24:59","date_gmt":"2026-02-25T10:24:59","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/id\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-diagram-comparison\/multi-level-dfd-vs-package-diagram\/"},"modified":"2026-02-25T10:24:59","modified_gmt":"2026-02-25T10:24:59","slug":"multi-level-dfd-vs-package-diagram","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/id\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-diagram-comparison\/multi-level-dfd-vs-package-diagram\/","title":{"rendered":"Multi-Level DFDs vs. UML Package\/Component Diagrams"},"content":{"rendered":"<p>When modeling large-scale systems, the choice between functional hierarchy decomposition and deployment-organized namespaces isn&#8217;t just about style\u2014it&#8217;s a foundational architectural decision.<\/p>\n<p>Too often, teams default to UML packages because they&#8217;re familiar, only to find their models lagging in clarity when tracing data across layers.<\/p>\n<p>Multi-level DFDs, on the other hand, expose the true flow of data through successive levels of refinement\u2014revealing bottlenecks, redundancies, and integration risks early.<\/p>\n<p>My experience in financial systems, supply chains, and government platforms confirms a clear truth: **functional decomposition wins when data lineage is critical**, while **deployment-based organization excels when modularity and team ownership matter**.<\/p>\n<p>This chapter dissects the core differences between multi-level DFDs and UML package\/component diagrams. We\u2019ll explore real patterns from production systems, how to choose based on project goals, and when to use both in tandem\u2014without overcomplicating.<\/p>\n<h2>Functional vs Deployment Decomposition: The Core Divide<\/h2>\n<p>At the heart of the multi level DFD vs package diagram debate lies a fundamental difference in worldview.<\/p>\n<p>DFD hierarchy treats the system as a sequence of data transformations\u2014each level zooming into a process to reveal how inputs become outputs.<\/p>\n<p>UML packages treat the system as a collection of logical or physical units\u2014grouping classes, interfaces, and components by domain, function, or deployment environment.<\/p>\n<p>They solve different problems.<\/p>\n<h3>When Functional Decomposition is Superior<\/h3>\n<p>Use multi-level DFDs when:<\/p>\n<ul>\n<li>Your primary concern is **end-to-end data flow** across systems.<\/li>\n<li>You&#8217;re analyzing **regulatory compliance**, such as HIPAA, SOX, or PCI-DSS, where audit trails demand traceable transformations.<\/li>\n<li>You\u2019re working on **batch processing, reporting, or material flows** where data moves through stages.<\/li>\n<li>Stakeholders\u2014including business analysts and auditors\u2014need a common language focused on **what data moves where and how**.<\/li>\n<\/ul>\n<p>Consider a financial transaction system. A Level 0 DFD shows how customer payments flow from input, through clearing, to settlement. Level 1 breaks down &#8220;Clearing&#8221; into validation, reconciliation, and posting. This is not a class structure\u2014it\u2019s a **data pipeline**.<\/p>\n<p>Such clarity is impossible to achieve with a package diagram that groups classes like &#8220;PaymentValidationService&#8221; or &#8220;ReconciliationEngine&#8221; without showing how data transforms between them.<\/p>\n<h3>When Deployment\/Package Organization Shines<\/h3>\n<p>Use UML packages when:<\/p>\n<ul>\n<li>You&#8217;re designing distributed systems or microservices.<\/li>\n<li>Team ownership and modular boundaries are key.<\/li>\n<li>You need to manage dependencies, versioning, or interface contracts.<\/li>\n<li>Codebase structure and build pipelines are part of the delivery.<\/li>\n<\/ul>\n<p>For example, in an e-commerce backend, you might have packages: <code>order-processing<\/code>, <code>inventory-management<\/code>, <code>customer-service<\/code>. Each package contains classes and interfaces that collaborate to fulfill a domain responsibility.<\/p>\n<p>This is deployment-aware modeling\u2014ideal for developers, DevOps, and CI\/CD pipelines.<\/p>\n<p>But if you\u2019re asked to trace how a customer\u2019s credit card data flows from checkout to settlement, the package diagram alone won\u2019t answer that. You\u2019d need a DFD overlay.<\/p>\n<h2>Large System Modeling: Real Patterns and Trade-offs<\/h2>\n<p>For large systems, both approaches are often necessary\u2014but applied at different levels.<\/p>\n<p>Here\u2019s how I\u2019ve seen it work in practice:<\/p>\n<h3>Pattern 1: DFD-First for System Understanding<\/h3>\n<p>Start with a multi-level DFD to map the business logic of a supply chain system.<\/p>\n<p>Level 0: \u201cOrder Fulfillment\u201d \u2014 inputs: purchase order, inventory status; outputs: shipped goods, invoice.<\/p>\n<p>Level 1: Breaks \u201cFulfillment\u201d into \u201cCheck Inventory\u201d, \u201cReserve Stock\u201d, \u201cShip Order\u201d, \u201cGenerate Invoice\u201d.<\/p>\n<p>Level 2: For \u201cReserve Stock\u201d, show data flows: inventory record \u2192 reservation request \u2192 approval \u2192 reservation confirmed.<\/p>\n<p>This exposes whether inventory updates are atomic, whether backorders are handled, and where data is stale.<\/p>\n<p>After this, you can map to UML packages: <code>OrderFulfillment<\/code>, <code>InventoryReservation<\/code>, <code>Shipping<\/code>.<\/p>\n<p>But the DFD came first\u2014because it revealed the functional logic before we built the structure.<\/p>\n<h3>Pattern 2: Package Diagrams for Technical Architecture<\/h3>\n<p>In a large banking system, I once led a modernization effort where UML packages helped define microservices boundaries.<\/p>\n<p>We defined packages: <code>core-banking<\/code>, <code>loan-origination<\/code>, <code>customer-identity<\/code>, <code>compliance-reporting<\/code>.<\/p>\n<p>Each package had internal classes and external dependencies. But during reviews, we noticed data flow gaps: no visibility of how a customer\u2019s credit check result moved from identity to loan origination.<\/p>\n<p>We added a DFD overlay to the package diagram, showing the flow from <code>credit-check-service<\/code> to <code>loan-calculator<\/code>.<\/p>\n<p>The result? Clearer technical debt tracking and better audit readiness.<\/p>\n<p>This is the power of **layered modeling**: use DFDs for functional clarity, packages for deployment clarity.<\/p>\n<h3>Trade-off Comparison: DFD Hierarchy vs UML Packages<\/h3>\n<table>\n<tbody>\n<tr>\n<th>Aspect<\/th>\n<th>DFD Hierarchy<\/th>\n<th>UML Packages<\/th>\n<\/tr>\n<tr>\n<td>Primary Focus<\/td>\n<td>Data transformation and flow<\/td>\n<td>Logical or physical grouping of code<\/td>\n<\/tr>\n<tr>\n<td>Best For<\/td>\n<td>Requirements analysis, compliance, audit, batch flows<\/td>\n<td>Team ownership, code structure, deployment<\/td>\n<\/tr>\n<tr>\n<td>Strength<\/td>\n<td>End-to-end data lineage<\/td>\n<td>Dependency management, maintainability<\/td>\n<\/tr>\n<tr>\n<td>Weakness<\/td>\n<td>Doesn\u2019t show object behavior or state<\/td>\n<td>Can obscure data movement between modules<\/td>\n<\/tr>\n<tr>\n<td>Best When<\/td>\n<td>Data movement is the central concern<\/td>\n<td>Modularity and team autonomy are key<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Use DFDs when you\u2019re asking: \u201cWhere does the data go, and how does it change?\u201d<\/p>\n<p>Use packages when you\u2019re asking: \u201cWho owns this, and how does it connect to others?\u201d<\/p>\n<h2>When to Use Each: Decision Framework<\/h2>\n<p>Here\u2019s a simple decision tree based on real projects:<\/p>\n<ol>\n<li><strong>Is data lineage the top priority? (e.g., compliance, audit, batch processing)<\/strong> \u2192 Use multi-level DFD.<\/li>\n<li><strong>Is the system being built as modular services or microservices?<\/strong> \u2192 Start with UML packages.<\/li>\n<li><strong>Are stakeholders business analysts or auditors?<\/strong> \u2192 Prioritize DFD.<\/li>\n<li><strong>Are developers the primary audience?<\/strong> \u2192 Prioritize UML packages.<\/li>\n<li><strong>Are you modernizing a legacy system?<\/strong> \u2192 Begin with DFD to reverse-engineer data flows, then map to UML for implementation.<\/li>\n<\/ol>\n<p>There\u2019s no one-size-fits-all. But in over 20 years of modeling, I\u2019ve found that teams that **start with DFDs resolve ambiguity faster**, especially in regulated or data-heavy domains.<\/p>\n<p>That\u2019s not to say UML is inferior\u2014just that it serves a different purpose.<\/p>\n<p>When you see \u201cpackage\u201d and \u201cprocess\u201d used interchangeably, you\u2019re likely missing the distinction: a package is about <em>where<\/em> code lives; a process is about <em>how data changes<\/em>.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>Can I use both multi-level DFDs and UML packages in the same project?<\/h3>\n<p>Absolutely. Use DFDs for functional analysis and data flow clarity, and UML packages to structure code and manage dependencies. Many large systems use both in tandem\u2014DFD for requirements and architecture reviews, packages for developer handoff.<\/p>\n<h3>Why does DFD hierarchy work better than UML packages for compliance?<\/h3>\n<p>Compliance requires traceability: showing how data moves from source to destination and how it transforms. DFDs make this visible as flows. UML packages group code but don\u2019t inherently show data transformation paths.<\/p>\n<h3>Does DFD scale to large systems?<\/h3>\n<p>Yes\u2014but with discipline. Use Level 0 for high-level context, Level 1 for core processes, and Level 2+ only for critical components. Avoid over-decomposing. Use DFDs to guide, not replace, UML.<\/p>\n<h3>How do I map a DFD process to a UML package?<\/h3>\n<p>Map the process to a use case or a service component within the package. For example, \u201cInvoice Generation\u201d in DFD becomes a class or operation inside the <code>billing<\/code> package. The DFD shows *how* the data flows; the package shows *where* it lives.<\/p>\n<h3>When should I avoid DFDs?<\/h3>\n<p>When your system is primarily event-driven, reactive, or state-based\u2014like real-time trading or IoT. Here, UML state machines and sequence diagrams are better suited.<\/p>\n<h3>Can a package diagram replace a DFD?<\/h3>\n<p>No. A package diagram shows structure, not flow. You can infer flow in some cases, but it\u2019s not reliable. DFDs are designed for data movement; packages are not.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>When modeling large-scale systems, the choice between functional hierarchy decomposition and deployment-organized namespaces isn&#8217;t just about style\u2014it&#8217;s a foundational architectural decision. Too often, teams default to UML packages because they&#8217;re familiar, only to find their models lagging in clarity when tracing data across layers. Multi-level DFDs, on the other hand, expose the true flow of [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":792,"menu_order":5,"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-798","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>Multi Level DFD vs Package Diagram<\/title>\n<meta name=\"description\" content=\"Compare multi-level DFDs and UML package diagrams for large system modeling. Understand when functional decomposition beats deployment organization in system 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\/id\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-diagram-comparison\/multi-level-dfd-vs-package-diagram\/\" \/>\n<meta property=\"og:locale\" content=\"id_ID\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Multi Level DFD vs Package Diagram\" \/>\n<meta property=\"og:description\" content=\"Compare multi-level DFDs and UML package diagrams for large system modeling. Understand when functional decomposition beats deployment organization in system design.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/id\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-diagram-comparison\/multi-level-dfd-vs-package-diagram\/\" \/>\n<meta property=\"og:site_name\" content=\"Visual Paradigm Skills Indonesia\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Estimasi waktu membaca\" \/>\n\t<meta name=\"twitter:data1\" content=\"6 menit\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-diagram-comparison\/multi-level-dfd-vs-package-diagram\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/id\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-diagram-comparison\/multi-level-dfd-vs-package-diagram\/\",\"name\":\"Multi Level DFD vs Package Diagram\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/#website\"},\"datePublished\":\"2026-02-25T10:24:59+00:00\",\"description\":\"Compare multi-level DFDs and UML package diagrams for large system modeling. Understand when functional decomposition beats deployment organization in system design.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-diagram-comparison\/multi-level-dfd-vs-package-diagram\/#breadcrumb\"},\"inLanguage\":\"id\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/id\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-diagram-comparison\/multi-level-dfd-vs-package-diagram\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-diagram-comparison\/multi-level-dfd-vs-package-diagram\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/id\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Data Flow Diagrams vs. UML: When to Use Each\",\"item\":\"https:\/\/skills.visual-paradigm.com\/id\/docs\/dfd-vs-uml-when-to-use-each\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Detailed Diagram Type Comparisons\",\"item\":\"https:\/\/skills.visual-paradigm.com\/id\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-diagram-comparison\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Multi-Level DFDs vs. UML Package\/Component Diagrams\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/#website\",\"url\":\"https:\/\/skills.visual-paradigm.com\/id\/\",\"name\":\"Visual Paradigm Skills Indonesia\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/skills.visual-paradigm.com\/id\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"id\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/#organization\",\"name\":\"Visual Paradigm Skills Indonesia\",\"url\":\"https:\/\/skills.visual-paradigm.com\/id\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"id\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/id\/wp-content\/uploads\/sites\/7\/2026\/02\/favicon.svg\",\"contentUrl\":\"https:\/\/skills.visual-paradigm.com\/id\/wp-content\/uploads\/sites\/7\/2026\/02\/favicon.svg\",\"width\":70,\"height\":70,\"caption\":\"Visual Paradigm Skills Indonesia\"},\"image\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Multi Level DFD vs Package Diagram","description":"Compare multi-level DFDs and UML package diagrams for large system modeling. Understand when functional decomposition beats deployment organization in system 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\/id\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-diagram-comparison\/multi-level-dfd-vs-package-diagram\/","og_locale":"id_ID","og_type":"article","og_title":"Multi Level DFD vs Package Diagram","og_description":"Compare multi-level DFDs and UML package diagrams for large system modeling. Understand when functional decomposition beats deployment organization in system design.","og_url":"https:\/\/skills.visual-paradigm.com\/id\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-diagram-comparison\/multi-level-dfd-vs-package-diagram\/","og_site_name":"Visual Paradigm Skills Indonesia","twitter_card":"summary_large_image","twitter_misc":{"Estimasi waktu membaca":"6 menit"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/skills.visual-paradigm.com\/id\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-diagram-comparison\/multi-level-dfd-vs-package-diagram\/","url":"https:\/\/skills.visual-paradigm.com\/id\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-diagram-comparison\/multi-level-dfd-vs-package-diagram\/","name":"Multi Level DFD vs Package Diagram","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/id\/#website"},"datePublished":"2026-02-25T10:24:59+00:00","description":"Compare multi-level DFDs and UML package diagrams for large system modeling. Understand when functional decomposition beats deployment organization in system design.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/id\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-diagram-comparison\/multi-level-dfd-vs-package-diagram\/#breadcrumb"},"inLanguage":"id","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/id\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-diagram-comparison\/multi-level-dfd-vs-package-diagram\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/id\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-diagram-comparison\/multi-level-dfd-vs-package-diagram\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/id\/"},{"@type":"ListItem","position":2,"name":"Data Flow Diagrams vs. UML: When to Use Each","item":"https:\/\/skills.visual-paradigm.com\/id\/docs\/dfd-vs-uml-when-to-use-each\/"},{"@type":"ListItem","position":3,"name":"Detailed Diagram Type Comparisons","item":"https:\/\/skills.visual-paradigm.com\/id\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-diagram-comparison\/"},{"@type":"ListItem","position":4,"name":"Multi-Level DFDs vs. UML Package\/Component Diagrams"}]},{"@type":"WebSite","@id":"https:\/\/skills.visual-paradigm.com\/id\/#website","url":"https:\/\/skills.visual-paradigm.com\/id\/","name":"Visual Paradigm Skills Indonesia","description":"","publisher":{"@id":"https:\/\/skills.visual-paradigm.com\/id\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/skills.visual-paradigm.com\/id\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"id"},{"@type":"Organization","@id":"https:\/\/skills.visual-paradigm.com\/id\/#organization","name":"Visual Paradigm Skills Indonesia","url":"https:\/\/skills.visual-paradigm.com\/id\/","logo":{"@type":"ImageObject","inLanguage":"id","@id":"https:\/\/skills.visual-paradigm.com\/id\/#\/schema\/logo\/image\/","url":"https:\/\/skills.visual-paradigm.com\/id\/wp-content\/uploads\/sites\/7\/2026\/02\/favicon.svg","contentUrl":"https:\/\/skills.visual-paradigm.com\/id\/wp-content\/uploads\/sites\/7\/2026\/02\/favicon.svg","width":70,"height":70,"caption":"Visual Paradigm Skills Indonesia"},"image":{"@id":"https:\/\/skills.visual-paradigm.com\/id\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/docs\/798","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/docs"}],"about":[{"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/types\/docs"}],"author":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/docs\/798\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/docs\/792"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/media?parent=798"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/doc_tag?post=798"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}