{"id":1403,"date":"2026-02-25T10:40:53","date_gmt":"2026-02-25T10:40:53","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/es\/docs\/real-world-uml-case-studies-software-design\/core-modeling-disciplines\/uml-package-diagrams-large-projects\/"},"modified":"2026-02-25T10:40:53","modified_gmt":"2026-02-25T10:40:53","slug":"uml-package-diagrams-large-projects","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/es\/docs\/real-world-uml-case-studies-software-design\/core-modeling-disciplines\/uml-package-diagrams-large-projects\/","title":{"rendered":"Package Diagrams and Model Organization for Large Projects"},"content":{"rendered":"<p>Modular design isn\u2019t optional\u2014it\u2019s the foundation of maintainable systems. Too many teams begin with code and only later realize their architecture is tangled, fragile, and hard to evolve. The key to avoiding this lies in intentional model organization from day one. UML package diagrams are more than just visual containers\u2014they\u2019re the scaffolding for scalable software architecture.<\/p>\n<p>They structure complex systems into cohesive units, define boundaries, and expose dependencies that impact everything from deployment to testing. But their power comes not from following a rigid template. It comes from understanding how to decompose based on business domains, technical concerns, and change frequency.<\/p>\n<p>I\u2019ve seen teams spend months refactoring monoliths that could\u2019ve been structured properly from the start. A single well-placed package diagram can prevent that. This chapter delivers actionable strategies\u2014grounded in real projects across healthcare, finance, and logistics\u2014to help you build modular, readable, and maintainable systems.<\/p>\n<h2>Why UML Package Diagrams Are the Keystone of Scalable Design<\/h2>\n<p>When teams outgrow simple class diagrams, UML package diagrams become essential. They\u2019re not decorative\u2014they\u2019re diagnostic and prescriptive.<\/p>\n<p>Unlike class diagrams that focus on structure, package diagrams capture the high-level organization of a system. They answer: What belongs together? Who depends on whom? What changes independently?<\/p>\n<p>Think of them as the table of contents for your system\u2019s architecture. A good package diagram should let a new engineer understand the system\u2019s structure in under five minutes.<\/p>\n<h3>The Hidden Risk of Poor Package Design<\/h3>\n<p>Many teams treat packages as file folders\u2014grouping classes by name or location. This leads to a \u201cbucket of classes\u201d problem: everything is together, but nothing is cohesive.<\/p>\n<p>I once audited a banking application where the <code>com.bank.core<\/code> package contained transaction logic, user authentication, database configuration, and UI utilities. When a change to the database layer required a three-day refactoring, the entire team was blocked. The root cause? No separation of concerns. The package diagram was an afterthought, not a design tool.<\/p>\n<p>Use UML package diagrams to enforce domain-driven boundaries. A package should represent a single responsibility\u2014be it a business capability, a technical concern, or a deployment unit.<\/p>\n<h2>Strategies for Effective Modular Decomposition<\/h2>\n<p>Modular design isn\u2019t about making more packages. It\u2019s about making the right ones.<\/p>\n<h3>1. Start with Business Capabilities<\/h3>\n<p>Break your system into domains based on business functions: Orders, Payments, Inventory, User Management.<\/p>\n<p>Each domain becomes a package. This aligns with domain-driven design principles and ensures your model reflects real-world operations.<\/p>\n<p>Example: In a hospital system, <code>patient-management<\/code>, <code>appointment-scheduling<\/code>, and <code>billing<\/code> are natural packages.<\/p>\n<h3>2. Apply the Single Responsibility Principle to Packages<\/h3>\n<p>A package should change for only one reason. If a change to logging affects the authentication module, that\u2019s a red flag\u2014those concerns shouldn\u2019t be in the same package.<\/p>\n<p>Use dependency rules to enforce this. In Visual Paradigm, you can define constraints to block unwanted dependencies.<\/p>\n<h3>3. Use Layers to Organize Technical Concerns<\/h3>\n<p>Organize packages into layers: <code>presentation<\/code>, <code>application<\/code>, <code>domain<\/code>, <code>infrastructure<\/code>. This mirrors the onion architecture and helps surface cross-cutting concerns.<\/p>\n<p>But don\u2019t force layers into every system. Some systems are event-driven or microservices-based. The layering should reflect the actual flow of responsibility.<\/p>\n<h3>4. Prioritize Changes Over Structure<\/h3>\n<p>Ask: Which parts of the system change most often? Those should be isolated in their own packages.<\/p>\n<p>For example, in a logistics platform, the dispatching logic changes frequently due to route optimization. Keep it in a dedicated <code>dispatching<\/code> package, independent of the core delivery tracking logic.<\/p>\n<h2>Building a Reusable UML Project Structure<\/h2>\n<p>A consistent UML project structure isn&#8217;t about uniformity\u2014it&#8217;s about predictability. It helps teams onboard faster, maintain consistency, and reduce cognitive load.<\/p>\n<h3>Recommended UML Project Structure Pattern<\/h3>\n<ul>\n<li><strong>src\/main\/java<\/strong> \u2013 Application source code (mapped via packages)<\/li>\n<li><strong>diagrams<\/strong> \u2013 UML model files (e.g., <code>use-case-diagrams.pdm<\/code>)<\/li>\n<li><strong>models<\/strong> \u2013 Core models: <code>architecture.pdm<\/code>, <code>domain-model.pdm<\/code><\/li>\n<li><strong>docs<\/strong> \u2013 Generated documentation, architectural decisions<\/li>\n<\/ul>\n<p>Use this structure to group related models. For example, <code>models\/finance\/policies.pdm<\/code> contains the policy engine model.<\/p>\n<h3>Best Practices for UML Modular Design<\/h3>\n<ul>\n<li>Use clear, domain-specific names: <code>payment-processing<\/code>, not <code>module1<\/code>.<\/li>\n<li>Keep packages under 50 classes\u2014beyond that, they\u2019re hard to navigate.<\/li>\n<li>Group related packages under a common parent: <code>com.bank.finance<\/code>, <code>com.bank.risk<\/code>.<\/li>\n<li>Use dependency arrows to show direction of influence, not just code references.<\/li>\n<\/ul>\n<h2>Managing Dependencies: The Critical Insight<\/h2>\n<p>Dependencies are the hidden tension in large systems. Poor dependency management leads to fragile builds, hard-to-test modules, and cascading failures.<\/p>\n<p>UML package diagrams make dependencies visible. But visibility isn\u2019t enough. You must control them.<\/p>\n<h3>Dependency Rules to Enforce Stability<\/h3>\n<p>Define rules to restrict how packages interact. For example:<\/p>\n<ul>\n<li><strong>No dependency from <code>infrastructure<\/code> to <code>domain<\/code> (inversion of control).<\/strong><\/li>\n<li><strong>Only <code>application<\/code> can depend on <code>domain<\/code>.<\/strong><\/li>\n<li><strong>External libraries should be in <code>lib<\/code> or <code>external<\/code> packages.<\/strong><\/li>\n<\/ul>\n<p>In Visual Paradigm, you can use \u00abDependency Rules\u00bb or \u00abCode Inspection\u00bb to validate these at build time.<\/p>\n<h3>Measuring Package Health<\/h3>\n<p>Use metrics to assess package stability and coupling:<\/p>\n<table>\n<tbody>\n<tr>\n<th>Metric<\/th>\n<th>What It Measures<\/th>\n<th>Target<\/th>\n<\/tr>\n<tr>\n<td>Coupling Between Objects (CBO)<\/td>\n<td>How many classes depend on this one<\/td>\n<td>Keep low (preferably &lt; 5)<\/td>\n<\/tr>\n<tr>\n<td>Depth of Inheritance (DIT)<\/td>\n<td>How deep the class hierarchy goes<\/td>\n<td>Prefer shallow (\u2264 3)<\/td>\n<\/tr>\n<tr>\n<td>Package Cohesion<\/td>\n<td>How related are the classes in the package?<\/td>\n<td>High cohesion = good<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>High CBO or DIT values indicate a package may be doing too much.<\/p>\n<h2>Practical Example: Building a Reusable UML Project Structure<\/h2>\n<p>Let\u2019s walk through an e-commerce platform using UML modular design.<\/p>\n<p>Directory structure:<\/p>\n<pre><code>ecommerce-project\/\n\u251c\u2500\u2500 src\/main\/java\/\n\u2502   \u251c\u2500\u2500 com.ecommerce.order\/\n\u2502   \u251c\u2500\u2500 com.ecommerce.payment\/\n\u2502   \u2514\u2500\u2500 com.ecommerce.inventory\/\n\u251c\u2500\u2500 diagrams\/\n\u2502   \u251c\u2500\u2500 use-case-diagrams.pdm\n\u2502   \u2514\u2500\u2500 package-diagram.pdm\n\u251c\u2500\u2500 models\/\n\u2502   \u251c\u2500\u2500 domain-model.pdm\n\u2502   \u2514\u2500\u2500 integration-interfaces.pdm\n\u2514\u2500\u2500 docs\/\n    \u2514\u2500\u2500 architecture-decisions.md\n<\/code><\/pre>\n<p>Key features:<\/p>\n<ul>\n<li><code>com.ecommerce.order<\/code> depends on <code>payment<\/code> and <code>inventory<\/code>, but not the other way around.<\/li>\n<li>Payment uses a third-party gateway; its interface is in <code>integration-interfaces.pdm<\/code>.<\/li>\n<li>Domain model is shared across all packages via <code>domain-model.pdm<\/code>.<\/li>\n<\/ul>\n<p>This structure ensures changes to order logic don\u2019t require touching payment or inventory\u2014separation of concerns at scale.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>How many packages should I have in a large UML model?<\/h3>\n<p>There\u2019s no fixed number. The goal is cohesion and stability. A system with 500 classes might have 10\u201315 well-defined packages. A smaller app may need only 3\u20135. Focus on meaningful grouping, not arbitrary counts.<\/p>\n<h3>Can I use UML package diagrams with microservices?<\/h3>\n<p>Absolutely. Each microservice can have its own UML model, and the package diagram can represent the internal structure. You can also use package diagrams to define contracts between services\u2014like a shared library or API specification.<\/p>\n<h3>What tools help enforce UML modular design?<\/h3>\n<p>Visual Paradigm offers dependency validation, code generation, and team collaboration features. You can also use static analysis tools like SonarQube with UML extensions to check package rules during CI\/CD.<\/p>\n<h3>Should I model all packages in one diagram?<\/h3>\n<p>Not always. For large systems, use a hierarchical diagram: one top-level package diagram showing major components, with sub-diagrams for each. This prevents visual clutter and improves readability.<\/p>\n<h3>How do I handle shared components across packages?<\/h3>\n<p>Use a <code>shared<\/code> or <code>common<\/code> package. Avoid circular dependencies. If two packages depend on each other, consider extracting the shared logic into a third, independent package.<\/p>\n<h3>Can UML package diagrams replace architecture decision records (ADRs)?<\/h3>\n<p>Not directly. But they complement ADRs. A package diagram visualizes the decision, while an ADR documents the rationale. Use both: the diagram for clarity, the record for traceability.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Modular design isn\u2019t optional\u2014it\u2019s the foundation of maintainable systems. Too many teams begin with code and only later realize their architecture is tangled, fragile, and hard to evolve. The key to avoiding this lies in intentional model organization from day one. UML package diagrams are more than just visual containers\u2014they\u2019re the scaffolding for scalable software [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":1397,"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-1403","docs","type-docs","status-publish","hentry"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v27.2 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>UML Package Diagrams for Large Projects<\/title>\n<meta name=\"description\" content=\"Master UML package diagrams to create scalable, maintainable software architecture. Learn modular design and dependency management for large projects with practical, real-world strategies.\" \/>\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\/es\/docs\/real-world-uml-case-studies-software-design\/core-modeling-disciplines\/uml-package-diagrams-large-projects\/\" \/>\n<meta property=\"og:locale\" content=\"es_ES\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"UML Package Diagrams for Large Projects\" \/>\n<meta property=\"og:description\" content=\"Master UML package diagrams to create scalable, maintainable software architecture. Learn modular design and dependency management for large projects with practical, real-world strategies.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/es\/docs\/real-world-uml-case-studies-software-design\/core-modeling-disciplines\/uml-package-diagrams-large-projects\/\" \/>\n<meta property=\"og:site_name\" content=\"Visual Paradigm Skills Espa\u00f1ol\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Tiempo de lectura\" \/>\n\t<meta name=\"twitter:data1\" content=\"6 minutos\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/es\/docs\/real-world-uml-case-studies-software-design\/core-modeling-disciplines\/uml-package-diagrams-large-projects\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/es\/docs\/real-world-uml-case-studies-software-design\/core-modeling-disciplines\/uml-package-diagrams-large-projects\/\",\"name\":\"UML Package Diagrams for Large Projects\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/es\/#website\"},\"datePublished\":\"2026-02-25T10:40:53+00:00\",\"description\":\"Master UML package diagrams to create scalable, maintainable software architecture. Learn modular design and dependency management for large projects with practical, real-world strategies.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/es\/docs\/real-world-uml-case-studies-software-design\/core-modeling-disciplines\/uml-package-diagrams-large-projects\/#breadcrumb\"},\"inLanguage\":\"es\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/es\/docs\/real-world-uml-case-studies-software-design\/core-modeling-disciplines\/uml-package-diagrams-large-projects\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/es\/docs\/real-world-uml-case-studies-software-design\/core-modeling-disciplines\/uml-package-diagrams-large-projects\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/es\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Real-World UML: Case Studies in Software Design\",\"item\":\"https:\/\/skills.visual-paradigm.com\/es\/docs\/real-world-uml-case-studies-software-design\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Core Modeling Disciplines\",\"item\":\"https:\/\/skills.visual-paradigm.com\/es\/docs\/real-world-uml-case-studies-software-design\/core-modeling-disciplines\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Package Diagrams and Model Organization for Large Projects\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/es\/#website\",\"url\":\"https:\/\/skills.visual-paradigm.com\/es\/\",\"name\":\"Visual Paradigm Skills Espa\u00f1ol\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/es\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/skills.visual-paradigm.com\/es\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"es\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/es\/#organization\",\"name\":\"Visual Paradigm Skills Espa\u00f1ol\",\"url\":\"https:\/\/skills.visual-paradigm.com\/es\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/es\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/es\/wp-content\/uploads\/sites\/5\/2026\/02\/favicon.svg\",\"contentUrl\":\"https:\/\/skills.visual-paradigm.com\/es\/wp-content\/uploads\/sites\/5\/2026\/02\/favicon.svg\",\"width\":70,\"height\":70,\"caption\":\"Visual Paradigm Skills Espa\u00f1ol\"},\"image\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/es\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"UML Package Diagrams for Large Projects","description":"Master UML package diagrams to create scalable, maintainable software architecture. Learn modular design and dependency management for large projects with practical, real-world strategies.","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\/es\/docs\/real-world-uml-case-studies-software-design\/core-modeling-disciplines\/uml-package-diagrams-large-projects\/","og_locale":"es_ES","og_type":"article","og_title":"UML Package Diagrams for Large Projects","og_description":"Master UML package diagrams to create scalable, maintainable software architecture. Learn modular design and dependency management for large projects with practical, real-world strategies.","og_url":"https:\/\/skills.visual-paradigm.com\/es\/docs\/real-world-uml-case-studies-software-design\/core-modeling-disciplines\/uml-package-diagrams-large-projects\/","og_site_name":"Visual Paradigm Skills Espa\u00f1ol","twitter_card":"summary_large_image","twitter_misc":{"Tiempo de lectura":"6 minutos"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/skills.visual-paradigm.com\/es\/docs\/real-world-uml-case-studies-software-design\/core-modeling-disciplines\/uml-package-diagrams-large-projects\/","url":"https:\/\/skills.visual-paradigm.com\/es\/docs\/real-world-uml-case-studies-software-design\/core-modeling-disciplines\/uml-package-diagrams-large-projects\/","name":"UML Package Diagrams for Large Projects","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/es\/#website"},"datePublished":"2026-02-25T10:40:53+00:00","description":"Master UML package diagrams to create scalable, maintainable software architecture. Learn modular design and dependency management for large projects with practical, real-world strategies.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/es\/docs\/real-world-uml-case-studies-software-design\/core-modeling-disciplines\/uml-package-diagrams-large-projects\/#breadcrumb"},"inLanguage":"es","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/es\/docs\/real-world-uml-case-studies-software-design\/core-modeling-disciplines\/uml-package-diagrams-large-projects\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/es\/docs\/real-world-uml-case-studies-software-design\/core-modeling-disciplines\/uml-package-diagrams-large-projects\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/es\/"},{"@type":"ListItem","position":2,"name":"Real-World UML: Case Studies in Software Design","item":"https:\/\/skills.visual-paradigm.com\/es\/docs\/real-world-uml-case-studies-software-design\/"},{"@type":"ListItem","position":3,"name":"Core Modeling Disciplines","item":"https:\/\/skills.visual-paradigm.com\/es\/docs\/real-world-uml-case-studies-software-design\/core-modeling-disciplines\/"},{"@type":"ListItem","position":4,"name":"Package Diagrams and Model Organization for Large Projects"}]},{"@type":"WebSite","@id":"https:\/\/skills.visual-paradigm.com\/es\/#website","url":"https:\/\/skills.visual-paradigm.com\/es\/","name":"Visual Paradigm Skills Espa\u00f1ol","description":"","publisher":{"@id":"https:\/\/skills.visual-paradigm.com\/es\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/skills.visual-paradigm.com\/es\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"es"},{"@type":"Organization","@id":"https:\/\/skills.visual-paradigm.com\/es\/#organization","name":"Visual Paradigm Skills Espa\u00f1ol","url":"https:\/\/skills.visual-paradigm.com\/es\/","logo":{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/skills.visual-paradigm.com\/es\/#\/schema\/logo\/image\/","url":"https:\/\/skills.visual-paradigm.com\/es\/wp-content\/uploads\/sites\/5\/2026\/02\/favicon.svg","contentUrl":"https:\/\/skills.visual-paradigm.com\/es\/wp-content\/uploads\/sites\/5\/2026\/02\/favicon.svg","width":70,"height":70,"caption":"Visual Paradigm Skills Espa\u00f1ol"},"image":{"@id":"https:\/\/skills.visual-paradigm.com\/es\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/skills.visual-paradigm.com\/es\/wp-json\/wp\/v2\/docs\/1403","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/skills.visual-paradigm.com\/es\/wp-json\/wp\/v2\/docs"}],"about":[{"href":"https:\/\/skills.visual-paradigm.com\/es\/wp-json\/wp\/v2\/types\/docs"}],"author":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/es\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/skills.visual-paradigm.com\/es\/wp-json\/wp\/v2\/docs\/1403\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/es\/wp-json\/wp\/v2\/docs\/1397"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/es\/wp-json\/wp\/v2\/media?parent=1403"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/es\/wp-json\/wp\/v2\/doc_tag?post=1403"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}