{"id":1478,"date":"2026-02-25T10:42:07","date_gmt":"2026-02-25T10:42:07","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/vn\/docs\/soaml-diagram-fundamentals\/soaml-modeling-basics\/soaml-capabilities-and-interfaces\/"},"modified":"2026-02-25T10:42:07","modified_gmt":"2026-02-25T10:42:07","slug":"soaml-capabilities-and-interfaces","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/vn\/docs\/soaml-diagram-fundamentals\/soaml-modeling-basics\/soaml-capabilities-and-interfaces\/","title":{"rendered":"How to Model Capabilities and Interfaces"},"content":{"rendered":"<p>Imagine a company that\u2019s reorganizing its HR system. Instead of building a monolithic payroll module, the team identifies discrete, reusable functions: employee onboarding, leave management, and performance review. These aren\u2019t just features\u2014they\u2019re <strong>capabilities<\/strong>. In SoaML, these capabilities become the foundation for defining service interfaces. The real insight? Capabilities define *what* a system can do, while interfaces define *how* it does it.<\/p>\n<p>Too many teams jump straight into interface definitions without first clarifying what capabilities a system must support. This leads to overlapping, fragile services\u2014often because business intent gets lost in technical syntax. My advice after 20 years: model capabilities first, then map them to interfaces. It\u2019s a shift from thinking in terms of components to thinking in terms of value.<\/p>\n<p>This chapter guides you through <strong>SoaML capability modeling<\/strong> and <strong>SoaML interface definition<\/strong> with clear steps, real-world examples, and practical modeling decisions. You\u2019ll learn how to align business capabilities with service contracts, avoid common design pitfalls, and create models that scale with your organization\u2019s evolution.<\/p>\n<h2>Why Capability-Based Design Matters<\/h2>\n<p>Capability-based design is not just a modeling preference\u2014it\u2019s a strategic move toward resilience and reuse. A capability represents a specific business function or operational strength, such as &#8220;Generate Payroll&#8221; or &#8220;Process Employee Termination.&#8221;<\/p>\n<p>Unlike technical features, capabilities are meaningful to business stakeholders. They help bridge the gap between IT and business by making service boundaries reflect real-world operations.<\/p>\n<p>Consider a logistics company. Instead of modeling services named \u201cOrderUpdateService\u201d or \u201cShippingCalculationService,\u201d defining capabilities like \u201cManage Order Fulfillment\u201d or \u201cCalculate Delivery Estimates\u201d makes the model inherently more understandable and maintainable.<\/p>\n<ul>\n<li>Capabilities represent <strong>what<\/strong> a system does from a business perspective.<\/li>\n<li>Interfaces define <strong>how<\/strong> that function is accessed\u2014via operations, message formats, and protocols.<\/li>\n<li>One capability may support multiple interfaces, especially in hybrid deployment scenarios.<\/li>\n<\/ul>\n<h3>Mapping Business Capabilities to SoaML Elements<\/h3>\n<p>SoaML doesn\u2019t use \u201ccapability\u201d as a standalone element in the metamodel\u2014but you can model them effectively using <strong>Service<\/strong> and <strong>Service Interface<\/strong> constructs.<\/p>\n<p>Here\u2019s how I recommend structuring it:<\/p>\n<ol>\n<li>Start with a <code>Service<\/code> element representing the core business capability.<\/li>\n<li>Attach one or more <code>ServiceInterface<\/code> elements to it, each defining a different access pattern.<\/li>\n<li>Use the <code>capability<\/code> stereotype or a <code>Capability<\/code> classifier (if supported by your tool) to annotate the intent.<\/li>\n<\/ol>\n<p>For example:<\/p>\n<pre><code>Service [name=\"Payroll Processing\"]\n  \u2514\u2500\u2500 ServiceInterface [name=\"PayrollCalculationInterface\"]\n      \u2514\u2500\u2500 Operation [name=\"calculateNetPay\"]\n          \u2514\u2500\u2500 input: EmployeeData\n          \u2514\u2500\u2500 output: NetPayResult\n<\/code><\/pre>\n<p>This structure makes it clear that <em>Payroll Processing<\/em> is a capability, and it can be accessed via multiple interfaces\u2014say, one for internal HR systems and another for integration with third-party tax engines.<\/p>\n<h2>SoaML Capability Modeling: Practical Steps<\/h2>\n<p>Here\u2019s how to build a robust capability model step by step:<\/p>\n<ol>\n<li><strong>Identify core business capabilities<\/strong> from business process models or value streams. Ask: \u201cWhat value does this service deliver?\u201d<\/li>\n<li><strong>Group related functions<\/strong> under a single capability. Avoid splitting capabilities too finely\u2014granularity should reflect business ownership, not technical convenience.<\/li>\n<li><strong>Define service boundaries<\/strong> around capabilities. Ensure one capability does one thing, and one thing well.<\/li>\n<li><strong>Map capability to service<\/strong> in your SoaML model. Use the <code>Service<\/code> element to represent the capability.<\/li>\n<li><strong>Define one or more interfaces<\/strong> that expose the capability\u2019s operations.<\/li>\n<\/ol>\n<p>Use this checklist to validate your model:<\/p>\n<ul>\n<li>Does each capability have a clear business owner?<\/li>\n<li>Can the capability be independently developed, tested, and deployed?<\/li>\n<li>Are interfaces aligned with the capability\u2019s purpose, not just internal implementation?<\/li>\n<li>Do interfaces avoid duplicating functionality across services?<\/li>\n<\/ul>\n<h3>Common Pitfalls in SoaML Capability Modeling<\/h3>\n<p>Even experienced modelers make these mistakes:<\/p>\n<ul>\n<li><strong>Confusing capabilities with technical features<\/strong>: Modeling \u201cprocess employee data\u201d as a capability instead of \u201cManage Employee Lifecycle\u201d leads to poor alignment with business goals.<\/li>\n<li><strong>Over-granular capabilities<\/strong>: Creating a capability for each step in a workflow (e.g., \u201cCheck Employee Status,\u201d \u201cUpdate Address\u201d) fragments the system and increases communication overhead.<\/li>\n<li><strong>Ignoring business ownership<\/strong>: A capability should be owned by a single team. If multiple teams claim ownership, the model will reflect organizational friction.<\/li>\n<\/ul>\n<p>My rule: If a capability can\u2019t be owned by one team and deployed independently, it\u2019s not a valid capability in SoaML.<\/p>\n<h2>SoaML Interface Definition: From Capability to Access Contract<\/h2>\n<p>An interface is the public face of a capability. It defines <em>what<\/em> operations are available, <em>how<\/em> they are invoked, and <em>what<\/em> inputs and outputs to expect.<\/p>\n<p>Think of it as a contract between a provider and a consumer. The interface must be stable, discoverable, and reusable across multiple consumers.<\/p>\n<h3>Designing Reusable Interfaces<\/h3>\n<p>Here\u2019s how to design interfaces that scale:<\/p>\n<ul>\n<li>Use <strong>standardized operation names<\/strong> (e.g., <code>submitRequest<\/code>, <code>retrieveStatus<\/code>) to improve discoverability.<\/li>\n<li>Define <strong>clear input\/output messages<\/strong> using data types that are shared across services.<\/li>\n<li>Use <strong>versioning<\/strong> to manage changes\u2014e.g., <code>Interface_v2<\/code>\u2014and avoid breaking existing consumers.<\/li>\n<li>Document each operation with a brief description and expected error codes.<\/li>\n<\/ul>\n<p>For example:<\/p>\n<pre><code>ServiceInterface [name=\"EmployeeManagementInterface\"]\n  \u2514\u2500\u2500 Operation [name=\"requestLeave\"]\n      \u2514\u2500\u2500 input: LeaveRequest\n      \u2514\u2500\u2500 output: LeaveApprovalStatus\n      \u2514\u2500\u2500 exception: InvalidLeaveRequestException\n<\/code><\/pre>\n<h3>Interface vs. Service Contract: A Key Distinction<\/h3>\n<p>It\u2019s tempting to conflate <strong>interface<\/strong> and <strong>service contract<\/strong>. But they serve different purposes:<\/p>\n<ul>\n<li><strong>Interface<\/strong> defines <em>what<\/em> operations are available.<\/li>\n<li><strong>Service contract<\/strong> defines <em>how<\/em> the service behaves\u2014its policies, security, reliability, and transport details.<\/li>\n<\/ul>\n<p>In SoaML, the <code>ServiceContract<\/code> element captures this. It references the <code>ServiceInterface<\/code> and adds behavioral constraints:<\/p>\n<ul>\n<li>Message exchange pattern (e.g., request-response)<\/li>\n<li>Security requirements (e.g., OAuth 2.0)<\/li>\n<li>Retry policies, time-to-live, and fault tolerance<\/li>\n<\/ul>\n<p>This separation ensures that interface definition remains stable while contracts can be adjusted for deployment environments.<\/p>\n<h2>Capability-Based SoaML Design: A Real-World Example<\/h2>\n<p>Let\u2019s model a simple employee onboarding system using SoaML.<\/p>\n<h3>Step 1: Identify Business Capabilities<\/h3>\n<ul>\n<li>Onboard New Employee<\/li>\n<li>Assign Workstation and Access<\/li>\n<li>Enroll in Benefits Program<\/li>\n<\/ul>\n<h3>Step 2: Map to SoaML Elements<\/h3>\n<ul>\n<li><code>Service [name=\"Employee Onboarding Service\"]<\/code> \u2192 represents the top-level capability.<\/li>\n<li><code>ServiceInterface [name=\"OnboardingInterface\"]<\/code> \u2192 defines operations like <code>startOnboardingProcess<\/code>.<\/li>\n<li><code>ServiceInterface [name=\"BenefitsEnrollmentInterface\"]<\/code> \u2192 for benefits-related operations.<\/li>\n<\/ul>\n<h3>Step 3: Define Interface Operations<\/h3>\n<pre><code>ServiceInterface [name=\"OnboardingInterface\"]\n  \u2514\u2500\u2500 Operation [name=\"startOnboardingProcess\"]\n      \u2514\u2500\u2500 input: OnboardingRequest\n      \u2514\u2500\u2500 output: OnboardingReferenceNumber\n<\/code><\/pre>\n<p>Now, each interface is tied to a clear capability. The model is not just a technical diagram\u2014it\u2019s a business agreement.<\/p>\n<h2>Key Takeaways<\/h2>\n<p>Modeling capabilities and interfaces in SoaML is not about notation\u2014it\u2019s about intention. When done well, it fosters:<\/p>\n<ul>\n<li>Clearer communication between business and IT.<\/li>\n<li>Stronger reusability across systems.<\/li>\n<li>Loose coupling between services.<\/li>\n<li>Long-term maintainability and evolution.<\/li>\n<\/ul>\n<p>Remember: <strong>capability-based SoaML design<\/strong> is not a one-off exercise. It should be revisited during sprint planning, architecture reviews, or when new business domains emerge.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>What is the difference between a capability and a service in SoaML?<\/h3>\n<p>A <strong>capability<\/strong> is a business function (e.g., \u201cProcess Payroll\u201d). A <strong>service<\/strong> is the technical implementation of that capability. In SoaML, you model the service to represent the capability, often using the <code>Service<\/code> and <code>ServiceInterface<\/code> elements.<\/p>\n<h3>Can one capability have multiple interfaces?<\/h3>\n<p>Yes. A single capability may support multiple interface types\u2014for example, a REST API and a SOAP endpoint. Each interface defines a different access method, but both serve the same business capability.<\/p>\n<h3>How do I avoid interface bloat in SoaML?<\/h3>\n<p>Apply the <strong>single responsibility principle<\/strong>. Each interface should expose operations tied to one business purpose. If you have 20 operations in one interface, consider splitting it into two or more.<\/p>\n<h3>Should I model capabilities in every SoaML diagram?<\/h3>\n<p>No. Capabilities are best modeled at the architectural level (e.g., <em>Service Architecture<\/em> or <em>Participant<\/em> diagrams). In detailed interface diagrams, focus on operations and message types. Use capability annotations or notes for context.<\/p>\n<h3>Can SoaML interfaces represent event-driven capabilities?<\/h3>\n<p>Yes. Use <code>ServiceInterface<\/code> with <em>publish-subscribe<\/em> patterns. Define operations like <code>publishEmployeeHiredEvent<\/code> and <code>subscribeToOnboardingEvents<\/code>. This supports event-driven capabilities like \u201cNotify HR of New Hires.\u201d<\/p>\n<h3>How does SoaML capability modeling support microservices?<\/h3>\n<p>Each microservice should encapsulate one or more business capabilities. By modeling capabilities first, you ensure service boundaries align with business domains. This reduces cross-cutting concerns and supports autonomous deployment.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Imagine a company that\u2019s reorganizing its HR system. Instead of building a monolithic payroll module, the team identifies discrete, reusable functions: employee onboarding, leave management, and performance review. These aren\u2019t just features\u2014they\u2019re capabilities. In SoaML, these capabilities become the foundation for defining service interfaces. The real insight? Capabilities define *what* a system can do, while [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":1474,"menu_order":3,"template":"","meta":{"_acf_changed":false,"inline_featured_image":false,"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"doc_tag":[],"class_list":["post-1478","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>SoaML Capabilities and Interfaces<\/title>\n<meta name=\"description\" content=\"Learn how to model capabilities and interfaces in SoaML for better service modularity, reusability, and system interoperability. Master capability-based SoaML design with practical guidance.\" \/>\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\/vn\/docs\/soaml-diagram-fundamentals\/soaml-modeling-basics\/soaml-capabilities-and-interfaces\/\" \/>\n<meta property=\"og:locale\" content=\"vi_VN\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"SoaML Capabilities and Interfaces\" \/>\n<meta property=\"og:description\" content=\"Learn how to model capabilities and interfaces in SoaML for better service modularity, reusability, and system interoperability. Master capability-based SoaML design with practical guidance.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/vn\/docs\/soaml-diagram-fundamentals\/soaml-modeling-basics\/soaml-capabilities-and-interfaces\/\" \/>\n<meta property=\"og:site_name\" content=\"Visual Paradigm Skills Ti\u1ebfng Vi\u1ec7t\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u01af\u1edbc t\u00ednh th\u1eddi gian \u0111\u1ecdc\" \/>\n\t<meta name=\"twitter:data1\" content=\"6 ph\u00fat\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/vn\/docs\/soaml-diagram-fundamentals\/soaml-modeling-basics\/soaml-capabilities-and-interfaces\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/vn\/docs\/soaml-diagram-fundamentals\/soaml-modeling-basics\/soaml-capabilities-and-interfaces\/\",\"name\":\"SoaML Capabilities and Interfaces\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/vn\/#website\"},\"datePublished\":\"2026-02-25T10:42:07+00:00\",\"description\":\"Learn how to model capabilities and interfaces in SoaML for better service modularity, reusability, and system interoperability. Master capability-based SoaML design with practical guidance.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/vn\/docs\/soaml-diagram-fundamentals\/soaml-modeling-basics\/soaml-capabilities-and-interfaces\/#breadcrumb\"},\"inLanguage\":\"vi\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/vn\/docs\/soaml-diagram-fundamentals\/soaml-modeling-basics\/soaml-capabilities-and-interfaces\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/vn\/docs\/soaml-diagram-fundamentals\/soaml-modeling-basics\/soaml-capabilities-and-interfaces\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/vn\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"SoaML Diagram Fundamentals: A Beginner\u2019s Guide\",\"item\":\"https:\/\/skills.visual-paradigm.com\/vn\/docs\/soaml-diagram-fundamentals\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Building Blocks of SoaML Diagrams\",\"item\":\"https:\/\/skills.visual-paradigm.com\/vn\/docs\/soaml-diagram-fundamentals\/soaml-modeling-basics\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"How to Model Capabilities and Interfaces\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/vn\/#website\",\"url\":\"https:\/\/skills.visual-paradigm.com\/vn\/\",\"name\":\"Visual Paradigm Skills Ti\u1ebfng Vi\u1ec7t\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/vn\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/skills.visual-paradigm.com\/vn\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"vi\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/vn\/#organization\",\"name\":\"Visual Paradigm Skills Ti\u1ebfng Vi\u1ec7t\",\"url\":\"https:\/\/skills.visual-paradigm.com\/vn\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"vi\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/vn\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/vn\/wp-content\/uploads\/sites\/11\/2026\/02\/favicon.svg\",\"contentUrl\":\"https:\/\/skills.visual-paradigm.com\/vn\/wp-content\/uploads\/sites\/11\/2026\/02\/favicon.svg\",\"width\":70,\"height\":70,\"caption\":\"Visual Paradigm Skills Ti\u1ebfng Vi\u1ec7t\"},\"image\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/vn\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"SoaML Capabilities and Interfaces","description":"Learn how to model capabilities and interfaces in SoaML for better service modularity, reusability, and system interoperability. Master capability-based SoaML design with practical guidance.","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\/vn\/docs\/soaml-diagram-fundamentals\/soaml-modeling-basics\/soaml-capabilities-and-interfaces\/","og_locale":"vi_VN","og_type":"article","og_title":"SoaML Capabilities and Interfaces","og_description":"Learn how to model capabilities and interfaces in SoaML for better service modularity, reusability, and system interoperability. Master capability-based SoaML design with practical guidance.","og_url":"https:\/\/skills.visual-paradigm.com\/vn\/docs\/soaml-diagram-fundamentals\/soaml-modeling-basics\/soaml-capabilities-and-interfaces\/","og_site_name":"Visual Paradigm Skills Ti\u1ebfng Vi\u1ec7t","twitter_card":"summary_large_image","twitter_misc":{"\u01af\u1edbc t\u00ednh th\u1eddi gian \u0111\u1ecdc":"6 ph\u00fat"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/skills.visual-paradigm.com\/vn\/docs\/soaml-diagram-fundamentals\/soaml-modeling-basics\/soaml-capabilities-and-interfaces\/","url":"https:\/\/skills.visual-paradigm.com\/vn\/docs\/soaml-diagram-fundamentals\/soaml-modeling-basics\/soaml-capabilities-and-interfaces\/","name":"SoaML Capabilities and Interfaces","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/vn\/#website"},"datePublished":"2026-02-25T10:42:07+00:00","description":"Learn how to model capabilities and interfaces in SoaML for better service modularity, reusability, and system interoperability. Master capability-based SoaML design with practical guidance.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/vn\/docs\/soaml-diagram-fundamentals\/soaml-modeling-basics\/soaml-capabilities-and-interfaces\/#breadcrumb"},"inLanguage":"vi","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/vn\/docs\/soaml-diagram-fundamentals\/soaml-modeling-basics\/soaml-capabilities-and-interfaces\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/vn\/docs\/soaml-diagram-fundamentals\/soaml-modeling-basics\/soaml-capabilities-and-interfaces\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/vn\/"},{"@type":"ListItem","position":2,"name":"SoaML Diagram Fundamentals: A Beginner\u2019s Guide","item":"https:\/\/skills.visual-paradigm.com\/vn\/docs\/soaml-diagram-fundamentals\/"},{"@type":"ListItem","position":3,"name":"Building Blocks of SoaML Diagrams","item":"https:\/\/skills.visual-paradigm.com\/vn\/docs\/soaml-diagram-fundamentals\/soaml-modeling-basics\/"},{"@type":"ListItem","position":4,"name":"How to Model Capabilities and Interfaces"}]},{"@type":"WebSite","@id":"https:\/\/skills.visual-paradigm.com\/vn\/#website","url":"https:\/\/skills.visual-paradigm.com\/vn\/","name":"Visual Paradigm Skills Ti\u1ebfng Vi\u1ec7t","description":"","publisher":{"@id":"https:\/\/skills.visual-paradigm.com\/vn\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/skills.visual-paradigm.com\/vn\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"vi"},{"@type":"Organization","@id":"https:\/\/skills.visual-paradigm.com\/vn\/#organization","name":"Visual Paradigm Skills Ti\u1ebfng Vi\u1ec7t","url":"https:\/\/skills.visual-paradigm.com\/vn\/","logo":{"@type":"ImageObject","inLanguage":"vi","@id":"https:\/\/skills.visual-paradigm.com\/vn\/#\/schema\/logo\/image\/","url":"https:\/\/skills.visual-paradigm.com\/vn\/wp-content\/uploads\/sites\/11\/2026\/02\/favicon.svg","contentUrl":"https:\/\/skills.visual-paradigm.com\/vn\/wp-content\/uploads\/sites\/11\/2026\/02\/favicon.svg","width":70,"height":70,"caption":"Visual Paradigm Skills Ti\u1ebfng Vi\u1ec7t"},"image":{"@id":"https:\/\/skills.visual-paradigm.com\/vn\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/skills.visual-paradigm.com\/vn\/wp-json\/wp\/v2\/docs\/1478","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/skills.visual-paradigm.com\/vn\/wp-json\/wp\/v2\/docs"}],"about":[{"href":"https:\/\/skills.visual-paradigm.com\/vn\/wp-json\/wp\/v2\/types\/docs"}],"author":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/vn\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/skills.visual-paradigm.com\/vn\/wp-json\/wp\/v2\/docs\/1478\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/vn\/wp-json\/wp\/v2\/docs\/1474"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/vn\/wp-json\/wp\/v2\/media?parent=1478"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/vn\/wp-json\/wp\/v2\/doc_tag?post=1478"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}