{"id":1395,"date":"2026-02-25T10:40:50","date_gmt":"2026-02-25T10:40:50","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/id\/docs\/real-world-uml-case-studies-software-design\/foundations-of-practical-uml\/types-of-uml-diagrams-practical-guide\/"},"modified":"2026-02-25T10:40:50","modified_gmt":"2026-02-25T10:40:50","slug":"types-of-uml-diagrams-practical-guide","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/id\/docs\/real-world-uml-case-studies-software-design\/foundations-of-practical-uml\/types-of-uml-diagrams-practical-guide\/","title":{"rendered":"The UML Toolkit: Core Diagrams Every Developer Should Know"},"content":{"rendered":"<p>Most developers approach UML with the wrong mindset: they treat diagrams as documentation tools instead of design catalysts. The real prerequisite isn\u2019t familiarity with notation\u2014it\u2019s the habit of thinking in systems, not just code. When you start seeing relationships, behaviors, and states as interdependent elements of a whole, UML transforms from a checklist into a thinking partner.<\/p>\n<p>Over two decades of modeling across finance, healthcare, and IoT systems taught me that the most effective diagrams are those that answer a specific question. A class diagram isn\u2019t about drawing boxes\u2014it\u2019s about defining the structure an application will evolve around. A sequence diagram isn\u2019t just a timeline\u2014it\u2019s a behavioral contract between components.<\/p>\n<p>This chapter cuts through abstraction to show you exactly which UML diagram types matter in real projects, when to use them, and how to avoid common over-engineering traps. You\u2019ll get actionable, field-tested guidance\u2014not textbook definitions. By the end, you\u2019ll be able to choose the right diagram for your context, explain it to stakeholders, and trust it to guide development, not just decorate it.<\/p>\n<h2>Core UML Diagram Types: Purpose and Use Cases<\/h2>\n<h3>Class Diagrams: The Blueprint of Structure<\/h3>\n<p>Class diagrams are the backbone of object-oriented design. They model classes, attributes, methods, and their relationships\u2014inheritance, associations, dependencies, and multiplicity.<\/p>\n<p>They\u2019re not just for showing relationships. They\u2019re for catching design flaws early. I once spotted a circular dependency in a banking system\u2019s transaction model just by reviewing the class diagram\u2014before a single line of code was written.<\/p>\n<p>Use class diagrams when:<\/p>\n<ul>\n<li>Defining the core domain model in a domain-driven design (DDD) project.<\/li>\n<li>Documenting core system entities and their relationships.<\/li>\n<li>Planning how components will interact at the code level.<\/li>\n<\/ul>\n<p>Common UML notation like the stereotype \u00abentity\u00bb, \u00abboundary\u00bb, and \u00abcontrol\u00bb helps categorize classes quickly. Always label associations clearly\u2014ambiguous roles are a leading cause of runtime errors.<\/p>\n<h3>Use Case Diagrams: Capturing Functional Requirements<\/h3>\n<p>Use case diagrams translate user needs into system behavior. They show actors (roles) and the actions (use cases) they trigger, often grouped within a system boundary.<\/p>\n<p>They\u2019re not a substitute for detailed user stories\u2014but they provide a high-level view of system scope. I\u2019ve seen teams waste weeks building features that weren\u2019t even in the use case model because they skipped this step.<\/p>\n<p>Best practices:<\/p>\n<ul>\n<li>Keep the number of use cases under 15 per diagram.<\/li>\n<li>Use generalization to avoid duplication\u2014e.g., \u00abextends\u00bb for optional behavior.<\/li>\n<li>Link use cases to detailed specifications using traceability.<\/li>\n<\/ul>\n<p>When modeling a hospital system, I used one diagram to represent patient intake, lab testing, and billing\u2014each tied to the right actors. It became the single point of truth during sprint planning.<\/p>\n<h3>Sequence Diagrams: Modeling Interactions Over Time<\/h3>\n<p>Sequence diagrams visualize the flow of messages between objects over time. They show lifelines, activation bars, and message ordering\u2014ideal for complex or asynchronous flows.<\/p>\n<p>They\u2019re not just for show. A well-drawn sequence diagram can prevent race conditions and deadlocks. In a real-time logistics app, a sequence diagram uncovered a missing timeout in a tracking update flow\u2014something our QA team missed for months.<\/p>\n<p>When to use it:<\/p>\n<ul>\n<li>Designing API interactions, especially across microservices.<\/li>\n<li>Modeling authentication flows, such as OAuth or JWT token exchange.<\/li>\n<li>Debugging complex event-driven systems.<\/li>\n<\/ul>\n<p>Keep it focused. A sequence with more than 5\u20136 lifelines becomes unreadable. Break large flows into sub-diagrams if needed.<\/p>\n<h3>Activity Diagrams: Mapping Business and System Flows<\/h3>\n<p>Activity diagrams model workflows\u2014both business processes and internal system logic. They use actions, decisions, flows, and forks to represent control flow.<\/p>\n<p>They\u2019re excellent for visualizing workflows that involve parallel or conditional steps. In an e-commerce platform, I used one to model order fulfillment: from payment confirmation to inventory deduction, dispatch, and tracking updates.<\/p>\n<p>Key elements:<\/p>\n<ul>\n<li>Start with an initial node (solid circle).<\/li>\n<li>Use diamonds for decision points.<\/li>\n<li>Use bars for parallel branches.<\/li>\n<\/ul>\n<p>Activity diagrams are often misunderstood as simple flowcharts. But their real power lies in synchronizing parallel paths and modeling exception handling\u2014something most developers overlook.<\/p>\n<h3>State Machine Diagrams: Capturing Lifecycle Behavior<!--3--><\/p>\n<p>State machine diagrams model how an object\u2019s behavior changes in response to events. They show states, transitions, events, and internal actions.<\/p>\n<p>These diagrams are invaluable for modeling systems with complex lifecycle rules\u2014like a payment processor that transitions from &#8220;pending&#8221; to &#8220;confirmed&#8221; or &#8220;failed&#8221; based on external signals.<\/p>\n<p>Use them when:<\/p>\n<ul>\n<li>Modeling the behavior of a single object over time (e.g., a user session, a ticket, a shipment).<\/li>\n<li>Defining business or system states that trigger actions.<\/li>\n<li>Validating that all transitions are accounted for.<\/li>\n<\/ul>\n<p>I once used a state diagram to prevent a hospital\u2019s patient monitoring system from misreporting \u201ccritical\u201d status due to a missing transition from \u201cstable\u201d to \u201calert\u201d under specific conditions. It was the only diagram that caught the logic gap.<\/p>\n<\/h3>\n<h3>Component and Deployment Diagrams: Bridging Logic and Infrastructure<\/h3>\n<p>These diagrams connect design to deployment. Component diagrams show how code modules relate\u2014interfaces, implementations, and dependencies. Deployment diagrams map components to physical nodes (servers, containers, devices).<\/p>\n<p>They\u2019re essential in distributed systems. A client-side component may depend on a backend API, which in turn runs in a Docker container on a Kubernetes cluster. A deployment diagram makes this clear.<\/p>\n<p>Use component diagrams to:<\/p>\n<ul>\n<li>Clarify modularity in large applications.<\/li>\n<li>Identify tight coupling and hidden dependencies.<\/li>\n<li>Support modular development and team ownership.<\/li>\n<\/ul>\n<p>Use deployment diagrams to:<\/p>\n<ul>\n<li>Design scalable and resilient architectures.<\/li>\n<li>Plan for load balancing, redundancy, and failover.<\/li>\n<li>Support DevOps and CI\/CD pipeline planning.<\/li>\n<\/ul>\n<p>Don\u2019t confuse them with class diagrams. Components are about code organization; nodes are about physical distribution.<\/p>\n<h2>Choosing the Right Diagram: A Decision Framework<\/h2>\n<p>Not every diagram is needed for every system. The key is to match the diagram to the problem.<\/p>\n<p>Here\u2019s a quick decision tree:<\/p>\n<ol>\n<li><strong>What\u2019s the goal?<\/strong> If you\u2019re defining structure\u2014use a class diagram.<\/li>\n<li><strong>Who are you talking to?<\/strong> For stakeholders, use use case diagrams. For engineers, use sequence or activity diagrams.<\/li>\n<li><strong>Is it a behavioral flow?<\/strong> Use activity or state diagrams for business processes.<\/li>\n<li><strong>Is it about deployment?<\/strong> Use deployment diagrams for cloud or embedded systems.<\/li>\n<\/ol>\n<p>Remember: <strong>one diagram per purpose<\/strong>. Overloading a diagram with too many concerns kills readability and defeats the purpose.<\/p>\n<h2>Common Pitfalls and How to Avoid Them<\/h2>\n<p>Even with the best intentions, modeling goes wrong. Here are three of the most frequent issues:<\/p>\n<ul>\n<li><strong>Too much detail.<\/strong> A class diagram with 50 classes and 100+ associations is unusable. Focus on the core domain. Remove implementation details.<\/li>\n<li><strong>Ignoring multiplicity.<\/strong> A missing \u00ab1..*\u00bb or \u00ab0..1\u00bb can lead to runtime errors. Always validate multiplicity with domain experts.<\/li>\n<li><strong>Confusing diagrams.<\/strong> Don\u2019t mix sequence and activity diagrams. Keep them separate. Use a legend if necessary.<\/li>\n<\/ul>\n<p>When in doubt, ask: <em>\u201cDoes this diagram help someone understand the system better or make a decision?\u201d<\/em> If not, it\u2019s clutter.<\/p>\n<h2>Key Takeaways<\/h2>\n<ul>\n<li>Types of UML diagrams serve distinct purposes\u2014choose based on context.<\/li>\n<li>Use case diagrams define scope. Class diagrams define structure. Sequence diagrams reveal behavior.<\/li>\n<li>Activity and state diagrams model complex flows. Component and deployment diagrams bridge design to deployment.<\/li>\n<li>Never over-model. A clean, focused diagram is more valuable than a cluttered one.<\/li>\n<li>Always validate with stakeholders and developers. A diagram is only useful if it\u2019s understood.<\/li>\n<\/ul>\n<p>Mastering UML isn\u2019t about memorizing notation\u2014it\u2019s about learning to think in systems. The right diagram at the right time turns ambiguity into clarity.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>What are the most common UML diagram types I should learn first?<\/h3>\n<p>Start with class, use case, and sequence diagrams. They cover 80% of real-world design needs. Activity and state diagrams come next for business logic. Deployment and component diagrams are essential for distributed systems.<\/p>\n<h3>When should I use an activity diagram instead of a sequence diagram?<\/h3>\n<p>Use activity diagrams for business workflows, process flows, or any scenario with parallel or branching logic. Use sequence diagrams for object-level interactions\u2014especially when timing, message order, or async behavior matters.<\/p>\n<h3>Can I use UML for non-software systems?<\/h3>\n<p>Absolutely. UML is used in healthcare (patient workflows), manufacturing (production lines), logistics (shipment tracking), and even architecture (building systems). The principles of modeling entities, states, and interactions apply universally.<\/p>\n<h3>How do I ensure consistency across UML diagrams?<\/h3>\n<p>Use a shared model repository. Define naming conventions. Use tools like Visual Paradigm to auto-generate code and update diagrams. Always link diagrams\u2014e.g., a use case should reference its sequence diagram.<\/p>\n<h3>Is it still worth learning UML with AI tools generating diagrams?<\/h3>\n<p>Yes. AI can suggest diagrams, but it can\u2019t replace your judgment. You must understand intent, context, and correctness. AI tools are assistants, not substitutes for expertise. The best models come from combining AI efficiency with human insight.<\/p>\n<h3>Do I need to use all UML diagrams in a project?<\/h3>\n<p>No. Only use diagrams that serve a purpose. A small application may only need class and sequence diagrams. A complex system may require all of them. Focus on clarity, not completeness.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Most developers approach UML with the wrong mindset: they treat diagrams as documentation tools instead of design catalysts. The real prerequisite isn\u2019t familiarity with notation\u2014it\u2019s the habit of thinking in systems, not just code. When you start seeing relationships, behaviors, and states as interdependent elements of a whole, UML transforms from a checklist into a [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":1390,"menu_order":4,"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-1395","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>Types of UML Diagrams: A Practical Guide<\/title>\n<meta name=\"description\" content=\"Master the common UML diagram types with this practical guide. Learn when and how to use each type with real-world insights and best practices for software design success.\" \/>\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\/real-world-uml-case-studies-software-design\/foundations-of-practical-uml\/types-of-uml-diagrams-practical-guide\/\" \/>\n<meta property=\"og:locale\" content=\"id_ID\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Types of UML Diagrams: A Practical Guide\" \/>\n<meta property=\"og:description\" content=\"Master the common UML diagram types with this practical guide. Learn when and how to use each type with real-world insights and best practices for software design success.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/id\/docs\/real-world-uml-case-studies-software-design\/foundations-of-practical-uml\/types-of-uml-diagrams-practical-guide\/\" \/>\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=\"7 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\/real-world-uml-case-studies-software-design\/foundations-of-practical-uml\/types-of-uml-diagrams-practical-guide\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/id\/docs\/real-world-uml-case-studies-software-design\/foundations-of-practical-uml\/types-of-uml-diagrams-practical-guide\/\",\"name\":\"Types of UML Diagrams: A Practical Guide\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/#website\"},\"datePublished\":\"2026-02-25T10:40:50+00:00\",\"description\":\"Master the common UML diagram types with this practical guide. Learn when and how to use each type with real-world insights and best practices for software design success.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/docs\/real-world-uml-case-studies-software-design\/foundations-of-practical-uml\/types-of-uml-diagrams-practical-guide\/#breadcrumb\"},\"inLanguage\":\"id\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/id\/docs\/real-world-uml-case-studies-software-design\/foundations-of-practical-uml\/types-of-uml-diagrams-practical-guide\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/docs\/real-world-uml-case-studies-software-design\/foundations-of-practical-uml\/types-of-uml-diagrams-practical-guide\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/id\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Real-World UML: Case Studies in Software Design\",\"item\":\"https:\/\/skills.visual-paradigm.com\/id\/docs\/real-world-uml-case-studies-software-design\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Foundations of Practical UML\",\"item\":\"https:\/\/skills.visual-paradigm.com\/id\/docs\/real-world-uml-case-studies-software-design\/foundations-of-practical-uml\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"The UML Toolkit: Core Diagrams Every Developer Should Know\"}]},{\"@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":"Types of UML Diagrams: A Practical Guide","description":"Master the common UML diagram types with this practical guide. Learn when and how to use each type with real-world insights and best practices for software design success.","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\/real-world-uml-case-studies-software-design\/foundations-of-practical-uml\/types-of-uml-diagrams-practical-guide\/","og_locale":"id_ID","og_type":"article","og_title":"Types of UML Diagrams: A Practical Guide","og_description":"Master the common UML diagram types with this practical guide. Learn when and how to use each type with real-world insights and best practices for software design success.","og_url":"https:\/\/skills.visual-paradigm.com\/id\/docs\/real-world-uml-case-studies-software-design\/foundations-of-practical-uml\/types-of-uml-diagrams-practical-guide\/","og_site_name":"Visual Paradigm Skills Indonesia","twitter_card":"summary_large_image","twitter_misc":{"Estimasi waktu membaca":"7 menit"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/skills.visual-paradigm.com\/id\/docs\/real-world-uml-case-studies-software-design\/foundations-of-practical-uml\/types-of-uml-diagrams-practical-guide\/","url":"https:\/\/skills.visual-paradigm.com\/id\/docs\/real-world-uml-case-studies-software-design\/foundations-of-practical-uml\/types-of-uml-diagrams-practical-guide\/","name":"Types of UML Diagrams: A Practical Guide","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/id\/#website"},"datePublished":"2026-02-25T10:40:50+00:00","description":"Master the common UML diagram types with this practical guide. Learn when and how to use each type with real-world insights and best practices for software design success.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/id\/docs\/real-world-uml-case-studies-software-design\/foundations-of-practical-uml\/types-of-uml-diagrams-practical-guide\/#breadcrumb"},"inLanguage":"id","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/id\/docs\/real-world-uml-case-studies-software-design\/foundations-of-practical-uml\/types-of-uml-diagrams-practical-guide\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/id\/docs\/real-world-uml-case-studies-software-design\/foundations-of-practical-uml\/types-of-uml-diagrams-practical-guide\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/id\/"},{"@type":"ListItem","position":2,"name":"Real-World UML: Case Studies in Software Design","item":"https:\/\/skills.visual-paradigm.com\/id\/docs\/real-world-uml-case-studies-software-design\/"},{"@type":"ListItem","position":3,"name":"Foundations of Practical UML","item":"https:\/\/skills.visual-paradigm.com\/id\/docs\/real-world-uml-case-studies-software-design\/foundations-of-practical-uml\/"},{"@type":"ListItem","position":4,"name":"The UML Toolkit: Core Diagrams Every Developer Should Know"}]},{"@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\/1395","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\/1395\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/docs\/1390"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/media?parent=1395"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/doc_tag?post=1395"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}