{"id":1796,"date":"2026-02-25T10:46:09","date_gmt":"2026-02-25T10:46:09","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/interface-modeling-agile-visualize-dependencies\/"},"modified":"2026-02-25T10:46:09","modified_gmt":"2026-02-25T10:46:09","slug":"interface-modeling-agile-visualize-dependencies","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/interface-modeling-agile-visualize-dependencies\/","title":{"rendered":"Modeling Dependencies and Interfaces Visually"},"content":{"rendered":"<p>\u201cWe\u2019ll figure it out later\u201d \u2014 that\u2019s what I hear most often when teams skip interface modeling upfront. It sounds harmless, but it\u2019s the first crack in the foundation of alignment. When dependencies aren\u2019t visualized early, stories get blocked, integration fails, and velocity stalls.<\/p>\n<p>At scale, technical interfaces aren\u2019t just design details \u2014 they\u2019re story enablers. Modeling them early turns abstract dependencies into shared, actionable understanding. This isn\u2019t about documentation for documentation\u2019s sake. It\u2019s about reducing uncertainty before work begins.<\/p>\n<p>Here, you\u2019ll learn how to use visual modeling interfaces to map technical boundary points, align story dependencies, and create shared understanding across teams. You\u2019ll see how interface modeling agile directly supports flow, reduces rework, and strengthens cross-team coordination.<\/p>\n<h2>Why Interfaces Are Hidden Story Dependencies<\/h2>\n<p>Most teams treat interfaces as a backend concern. But in large-scale Agile, interfaces are where stories meet \u2014 they\u2019re the seams where teams interlock.<\/p>\n<p>When a story in Team A depends on data from Team B\u2019s API, but the interface isn\u2019t defined, the story becomes ambiguous. What does \u201cdata\u201d mean? What format? What error codes should be handled? Without clarity, refinement becomes guesswork.<\/p>\n<p>That\u2019s why interface modeling agile isn\u2019t optional. It\u2019s the bridge between technical design and user value. Skipping it invites assumptions, rework, and integration chaos.<\/p>\n<h3>Real-World Example: The Missing Schema<\/h3>\n<p>At a financial services client, Team X built a \u201ctransaction reporting\u201d feature. They assumed Team Y would expose a JSON endpoint with a standard structure. But the actual API used a different schema. The story was \u201cdone\u201d \u2014 but integration failed.<\/p>\n<p>Post-mortem: the interface wasn\u2019t modeled or validated. A simple diagram would have caught the mismatch before development.<\/p>\n<h2>How Visual Modeling Interfaces Improves Story Clarity<\/h2>\n<p>Visual modeling interfaces transforms abstract dependency talk into concrete, shared understanding. It turns \u201cTeam B will deliver\u201d into \u201cTeam B will expose endpoint X with schema Y, via contract Z.\u201d<\/p>\n<p>Use interface diagrams to:<\/p>\n<ul>\n<li>Show data flow between teams<\/li>\n<li>Define input\/output expectations<\/li>\n<li>Flag potential failure points<\/li>\n<li>Support contract-first development<\/li>\n<\/ul>\n<p>These aren\u2019t just diagrams for architects. They\u2019re story enablers for product owners and developers alike.<\/p>\n<h3>Step-by-Step: Building a Visual Interface Model<\/h3>\n<ol>\n<li><strong>Identify the interface<\/strong>: Define the boundary point \u2014 e.g., \u201cPayment Service exposes API for transaction retrieval.\u201d<\/li>\n<li><strong>Map inputs and outputs<\/strong>: List required parameters, response formats, error codes.<\/li>\n<li><strong>Link to stories<\/strong>: Connect the interface to user stories that depend on it. Example: \u201cAs a user, I want to view my transaction history.\u201d<\/li>\n<li><strong>Label with contracts<\/strong>: Use a standard format \u2014 e.g., \u201cGET \/api\/transactions?userId={id} \u2192 200 JSON\u201d.<\/li>\n<li><strong>Review with stakeholders<\/strong>: Include developers, testers, and POs from both teams.<\/li>\n<\/ol>\n<p>This process turns a vague dependency into a testable, traceable, shared agreement.<\/p>\n<h2>Dependency Diagrams Agile: Map the Real Flow<\/h2>\n<p>Dependency diagrams agile go beyond story mapping. They show not just *what* stories depend on *what*, but *how* \u2014 through interfaces, APIs, or shared data.<\/p>\n<p>Use simple flow diagrams to visualize:<\/p>\n<ul>\n<li>Which story triggers a call to a service<\/li>\n<li>Which team owns the interface<\/li>\n<li>What data is exchanged<\/li>\n<li>When the dependency must be resolved<\/li>\n<\/ul>\n<p>These diagrams are not for perfection. They are for communication. A 10-minute sketch can prevent days of rework.<\/p>\n<h3>Example: Payment Processing Flow<\/h3>\n<pre><code>\n[User Story: View Transaction History]\n          \u2193\n[API Call: GET \/transactions?userId=123]\n          \u2193\n[Team A: Payment Service API]\n          \u2193\n[Returns: JSON array of transactions]\n          \u2193\n[Team B: Reporting Service consumes data]\n<\/code><\/pre>\n<p>This shows dependency flow in real-time. It reveals that Team B\u2019s story cannot start until Team A\u2019s API is ready \u2014 and that both teams must agree on the schema.<\/p>\n<h2>Choosing the Right Tools for Visual Modeling<\/h2>\n<p>You don\u2019t need complex tools. A whiteboard, sticky notes, or a simple diagram app works. The key is consistency and accessibility.<\/p>\n<p>For enterprise use, integrate interface models into your Agile tooling. Link interface diagrams to:<\/p>\n<ul>\n<li>Epics and features<\/li>\n<li>Story acceptance criteria<\/li>\n<li>Integration test cases<\/li>\n<li>CI\/CD pipelines<\/li>\n<\/ul>\n<p>When a story has a visual interface model attached, it becomes a shared asset \u2014 not a document, but a living artifact.<\/p>\n<h2>Pro Tip: Treat Interfaces Like Contracts<\/h2>\n<p>Think of interface modeling agile as a contract between teams. When the interface is defined, both teams agree on:<\/p>\n<ul>\n<li>Data format (JSON, XML)<\/li>\n<liauthentication method=\"\" (oauth,=\"\" api=\"\" key)<=\"\" li=\"\">\n<li>Error handling (HTTP 4xx, 5xx codes)<\/li>\n<li>Versioning strategy (e.g., v1, v2)<\/li>\n<\/liauthentication><\/ul>\n<p>When the contract is signed \u2014 via shared diagram or document \u2014 the dependency becomes predictable. Stories can be estimated, planned, and delivered with confidence.<\/p>\n<h2>Common Pitfalls and How to Avoid Them<\/h2>\n<p>Even when teams try, interface modeling fails if:<\/p>\n<ul>\n<li><strong>Only one team owns the model<\/strong> \u2192 Fix: Co-create with both teams.<\/li>\n<li><strong>Diagrams become outdated<\/strong> \u2192 Fix: Update during refinement, link to story.<\/li>\n<li><strong>No one owns interface changes<\/strong> \u2192 Fix: Assign a lead from each team.<\/li>\n<li><strong>Over-engineering<\/strong> \u2192 Fix: Start simple. Add only what\u2019s needed.<\/li>\n<\/ul>\n<p>Remember: the goal is not perfection. It\u2019s shared understanding.<\/p>\n<h2>Final Thoughts: From Assumptions to Alignment<\/h2>\n<p>Interface modeling agile isn\u2019t a ceremonial phase. It\u2019s a practical, continuous practice \u2014 especially at scale.<\/p>\n<p>When teams treat interfaces as shared artifacts, dependencies become visible, story flow improves, and integration risk drops.<\/p>\n<p>Start small: pick one story with a cross-team dependency, sketch the interface, review with both teams. That\u2019s the first step toward real agility.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>What\u2019s the difference between interface modeling and dependency mapping?<\/h3>\n<p>Dependency mapping shows *which stories depend on which*. Interface modeling agile goes further \u2014 it defines *how* they connect: what data, what format, what contract. It answers \u201chow\u201d not just \u201cwhat\u201d.<\/p>\n<h3>Do I need a formal diagram for every interface?<\/h3>\n<p>No. Use visual modeling interfaces only for high-impact or cross-team dependencies. For internal or low-risk interfaces, a simple note or shared acceptance criteria may suffice.<\/p>\n<h3>Who should own the interface diagram?<\/h3>\n<p>Ownership should be shared. The team that *consumes* the interface (e.g., reporting) and the team that *provides* it (e.g., payment) should co-create the model. The product owner facilitates.<\/p>\n<h3>How do I keep interface models up to date?<\/h3>\n<p>Link the model to the story. Update it during refinement. If the interface changes, update the story\u2019s acceptance criteria and notify the consuming team.<\/p>\n<h3>Can visual modeling interfaces replace API documentation?<\/h3>\n<p>No \u2014 they complement it. An interface diagram gives context and flow. API documentation provides technical specs. Use both.<\/p>\n<h3>How do interface models help with PI planning?<\/h3>\n<p>Interface models reveal integration risks early. During PI planning, they help identify which stories can be planned together and which need coordination. They reduce last-minute surprises.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>\u201cWe\u2019ll figure it out later\u201d \u2014 that\u2019s what I hear most often when teams skip interface modeling upfront. It sounds harmless, but it\u2019s the first crack in the foundation of alignment. When dependencies aren\u2019t visualized early, stories get blocked, integration fails, and velocity stalls. At scale, technical interfaces aren\u2019t just design details \u2014 they\u2019re story [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":1792,"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-1796","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>Interface Modeling Agile: Visualize Dependencies &amp; Interfaces<\/title>\n<meta name=\"description\" content=\"Master interface modeling agile with visual dependency diagrams to align architecture, stories, and teams. Use visual modeling interfaces to reduce risk and improve flow in enterprise Agile.\" \/>\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\/pt\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/interface-modeling-agile-visualize-dependencies\/\" \/>\n<meta property=\"og:locale\" content=\"pt_PT\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Interface Modeling Agile: Visualize Dependencies &amp; Interfaces\" \/>\n<meta property=\"og:description\" content=\"Master interface modeling agile with visual dependency diagrams to align architecture, stories, and teams. Use visual modeling interfaces to reduce risk and improve flow in enterprise Agile.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/interface-modeling-agile-visualize-dependencies\/\" \/>\n<meta property=\"og:site_name\" content=\"Visual Paradigm Skills Portugu\u00eas\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Tempo estimado de leitura\" \/>\n\t<meta name=\"twitter:data1\" content=\"4 minutos\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/interface-modeling-agile-visualize-dependencies\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/interface-modeling-agile-visualize-dependencies\/\",\"name\":\"Interface Modeling Agile: Visualize Dependencies & Interfaces\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/#website\"},\"datePublished\":\"2026-02-25T10:46:09+00:00\",\"description\":\"Master interface modeling agile with visual dependency diagrams to align architecture, stories, and teams. Use visual modeling interfaces to reduce risk and improve flow in enterprise Agile.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/interface-modeling-agile-visualize-dependencies\/#breadcrumb\"},\"inLanguage\":\"pt-PT\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/interface-modeling-agile-visualize-dependencies\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/interface-modeling-agile-visualize-dependencies\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pt\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"User Story Techniques for Large-Scale Agile Projects\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/user-story-techniques-large-scale-agile\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Advanced Story Patterns for Enterprises\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Modeling Dependencies and Interfaces Visually\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/#website\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pt\/\",\"name\":\"Visual Paradigm Skills Portugu\u00eas\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/skills.visual-paradigm.com\/pt\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"pt-PT\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/#organization\",\"name\":\"Visual Paradigm Skills Portugu\u00eas\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pt\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"pt-PT\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pt\/wp-content\/uploads\/sites\/9\/2026\/02\/favicon.svg\",\"contentUrl\":\"https:\/\/skills.visual-paradigm.com\/pt\/wp-content\/uploads\/sites\/9\/2026\/02\/favicon.svg\",\"width\":70,\"height\":70,\"caption\":\"Visual Paradigm Skills Portugu\u00eas\"},\"image\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Interface Modeling Agile: Visualize Dependencies & Interfaces","description":"Master interface modeling agile with visual dependency diagrams to align architecture, stories, and teams. Use visual modeling interfaces to reduce risk and improve flow in enterprise Agile.","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\/pt\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/interface-modeling-agile-visualize-dependencies\/","og_locale":"pt_PT","og_type":"article","og_title":"Interface Modeling Agile: Visualize Dependencies & Interfaces","og_description":"Master interface modeling agile with visual dependency diagrams to align architecture, stories, and teams. Use visual modeling interfaces to reduce risk and improve flow in enterprise Agile.","og_url":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/interface-modeling-agile-visualize-dependencies\/","og_site_name":"Visual Paradigm Skills Portugu\u00eas","twitter_card":"summary_large_image","twitter_misc":{"Tempo estimado de leitura":"4 minutos"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/interface-modeling-agile-visualize-dependencies\/","url":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/interface-modeling-agile-visualize-dependencies\/","name":"Interface Modeling Agile: Visualize Dependencies & Interfaces","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/pt\/#website"},"datePublished":"2026-02-25T10:46:09+00:00","description":"Master interface modeling agile with visual dependency diagrams to align architecture, stories, and teams. Use visual modeling interfaces to reduce risk and improve flow in enterprise Agile.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/interface-modeling-agile-visualize-dependencies\/#breadcrumb"},"inLanguage":"pt-PT","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/pt\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/interface-modeling-agile-visualize-dependencies\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/interface-modeling-agile-visualize-dependencies\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/pt\/"},{"@type":"ListItem","position":2,"name":"User Story Techniques for Large-Scale Agile Projects","item":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/user-story-techniques-large-scale-agile\/"},{"@type":"ListItem","position":3,"name":"Advanced Story Patterns for Enterprises","item":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/"},{"@type":"ListItem","position":4,"name":"Modeling Dependencies and Interfaces Visually"}]},{"@type":"WebSite","@id":"https:\/\/skills.visual-paradigm.com\/pt\/#website","url":"https:\/\/skills.visual-paradigm.com\/pt\/","name":"Visual Paradigm Skills Portugu\u00eas","description":"","publisher":{"@id":"https:\/\/skills.visual-paradigm.com\/pt\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/skills.visual-paradigm.com\/pt\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"pt-PT"},{"@type":"Organization","@id":"https:\/\/skills.visual-paradigm.com\/pt\/#organization","name":"Visual Paradigm Skills Portugu\u00eas","url":"https:\/\/skills.visual-paradigm.com\/pt\/","logo":{"@type":"ImageObject","inLanguage":"pt-PT","@id":"https:\/\/skills.visual-paradigm.com\/pt\/#\/schema\/logo\/image\/","url":"https:\/\/skills.visual-paradigm.com\/pt\/wp-content\/uploads\/sites\/9\/2026\/02\/favicon.svg","contentUrl":"https:\/\/skills.visual-paradigm.com\/pt\/wp-content\/uploads\/sites\/9\/2026\/02\/favicon.svg","width":70,"height":70,"caption":"Visual Paradigm Skills Portugu\u00eas"},"image":{"@id":"https:\/\/skills.visual-paradigm.com\/pt\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/docs\/1796","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/docs"}],"about":[{"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/types\/docs"}],"author":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/docs\/1796\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/docs\/1792"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/media?parent=1796"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/doc_tag?post=1796"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}