{"id":856,"date":"2026-02-25T10:25:43","date_gmt":"2026-02-25T10:25:43","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/es\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-agile\/"},"modified":"2026-03-02T09:06:57","modified_gmt":"2026-03-02T09:06:57","slug":"decision-tables-agile","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/es\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-agile\/","title":{"rendered":"Decision Tables in Agile and Scrum Environments"},"content":{"rendered":"<p>\u201cBreak down complex logic into simple, testable statements.\u201d This advice appears in dozens of agile guides. It sounds practical\u2014until you realize it\u2019s often incomplete. The real challenge isn\u2019t simplicity, but completeness. In my 20 years of modeling business logic, I\u2019ve seen teams miss critical edge cases because they treated logic as narrative, not structure. Decision tables agile fix that.<\/p>\n<p>Agile modeling techniques demand precision. Acceptance criteria must cover every path\u2014especially the ones no one expects. Decision tables in scrum turn ambiguity into actionability. They turn a vague \u201cif the user is over 18, approve\u201d into a full matrix of conditions and outcomes, ensuring no scenario slips through.<\/p>\n<p>Here, you\u2019ll learn how to embed decision tables into your agile workflow\u2014transforming user stories from vague promises into verifiable, testable, and reusable logic. You\u2019ll see how this approach prevents scope creep, reduces rework, and ensures sprint goals are met with confidence.<\/p>\n<h2>Why Decision Tables Excel in Agile and Scrum<\/h2>\n<p>Agile teams thrive on clear, testable outcomes. But many teams rely on informal language in acceptance criteria, leading to inconsistent interpretation across developers, testers, and product owners.<\/p>\n<p>Decision tables agile provide a structured alternative. They map every possible combination of conditions to its corresponding action, ensuring no logic is left untested.<\/p>\n<p>Consider a simple user story: \u201cAs a member, I want to qualify for a discount so I can reduce my payment.\u201d Without a decision table, the acceptance criteria might say:<\/p>\n<ul>\n<li>If the user has been a member for more than 12 months, apply a 10% discount.<\/li>\n<li>If the user has made more than 5 purchases, apply a 15% discount.<\/li>\n<\/ul>\n<p>But what if both conditions are true? Does the system apply 10%, 15%, or 25%? Does it apply both? This ambiguity leads to bugs, rework, and sprint fatigue.<\/p>\n<h3>The Power of Structured Condition Coverage<\/h3>\n<p>Decision tables in scrum eliminate this uncertainty. They force teams to define every possible combination\u2014especially the edge cases.<\/p>\n<p>Here\u2019s how it looks:<\/p>\n<table border=\"1\" cellspacing=\"0\" cellpadding=\"4\">\n<tbody>\n<tr>\n<th>Rule<\/th>\n<th>Member Duration &gt; 12 Months<\/th>\n<th>Purchases &gt; 5<\/th>\n<th>Action<\/th>\n<\/tr>\n<tr>\n<td>1<\/td>\n<td>No<\/td>\n<td>No<\/td>\n<td>No discount<\/td>\n<\/tr>\n<tr>\n<td>2<\/td>\n<td>Yes<\/td>\n<td>No<\/td>\n<td>10% discount<\/td>\n<\/tr>\n<tr>\n<td>3<\/td>\n<td>No<\/td>\n<td>Yes<\/td>\n<td>15% discount<\/td>\n<\/tr>\n<tr>\n<td>4<\/td>\n<td>Yes<\/td>\n<td>Yes<\/td>\n<td>Apply 25% (10% + 15%)<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>This table makes the logic unambiguous. It exposes when multiple rules apply and how they interact. It prevents assumptions.<\/p>\n<p>agile modeling techniques like this are not about replacing user stories. They\u2019re about strengthening them. A well-formed decision table ensures acceptance criteria are precise, complete, and verifiable.<\/p>\n<h2>Integrating Decision Tables into Sprint Planning<\/h2>\n<p>Sprint planning is where business logic gets shaped into deliverables. But too often, planning hinges on vague descriptions or assumptions.<\/p>\n<p>Using decision tables agile at this stage helps clarify what \u201cdone\u201d really means. It allows teams to estimate effort not just by task complexity, but by logical completeness.<\/p>\n<p>Here\u2019s how to integrate decision tables at the start of a sprint:<\/p>\n<ol>\n<li><strong>Extract the decision<\/strong>: Identify the core business rule from a user story. Example: \u201cEligibility for a premium membership discount.\u201d<\/li>\n<li><strong>Define conditions<\/strong>: List all relevant variables. e.g., Membership Duration, Number of Purchases, Payment Method.<\/li>\n<li><strong>Build the table<\/strong>: Create a matrix covering all combinations of true\/false for each condition.<\/li>\n<li><strong>Assign actions<\/strong>: Define the outcome for each rule\u2014e.g., \u201cApply 15% discount,\u201d \u201cDirect to review queue,\u201d \u201cReject.\u201d<\/li>\n<li><strong>Validate with the team<\/strong>: Walk through the table together to check for gaps, overlaps, or contradictions.<\/li>\n<\/ol>\n<p>Doing this during sprint planning transforms a discussion into a shared understanding. It also reveals hidden complexity\u2014like whether a discount applies only after a certain number of purchases, or if it\u2019s cumulative.<\/p>\n<h3>Agile Modeling Techniques: Beyond Narrative<\/h3>\n<p>Many teams use acceptance criteria as prose. But prose lacks structure. A decision table adds a layer of logic that prose cannot.<\/p>\n<p>For example, a user story about insurance claims might have a vague acceptance criterion: \u201cIf the claim is under $1,000, process quickly.\u201d But this ignores:<\/p>\n<ul>\n<li>What if the claim is under $1,000 but from a high-risk service?<\/li>\n<li>What if the claim is over $1,000 but includes a deductible?<\/li>\n<li>What if the patient is a new member?<\/li>\n<\/ul>\n<p>Decision tables in scrum help surface these edge cases before development begins. They force teams to think about every scenario\u2014something narrative formats often miss.<\/p>\n<h2>Scaling Decision Tables for Complex Rules<\/h2>\n<p>Not all decision logic is simple. In complex domains like finance, healthcare, or insurance, rules can involve multiple layers of conditionality.<\/p>\n<p>Here\u2019s where decision tables agile shine. They can be decomposed, modularized, and linked. You can create a main decision table for a high-level rule and link it to sub-tables for nested logic.<\/p>\n<p>For example:<\/p>\n<ul>\n<li>Main Table: \u201cApprove Claim?\u201d<\/li>\n<li>Sub-table: \u201cEligibility Based on Member Type\u201d<\/li>\n<li>Sub-table: \u201cClaim Amount Thresholds\u201d<\/li>\n<\/ul>\n<p>Each table handles a portion of the logic. This keeps the main table readable and reusable.<\/p>\n<p>When using agile modeling techniques, this modular approach also supports refactoring. If a rule changes\u2014say, the threshold drops from $5,000 to $3,000\u2014you update only the relevant sub-table. The rest remains unchanged.<\/p>\n<h2>Validating Logic: Preventing Hidden Errors<\/h2>\n<p>Even a small omission in a decision table can lead to business failure. A discount applied to the wrong user, a claim approved under incorrect conditions\u2014these issues don\u2019t always appear in testing.<\/p>\n<p>Use this checklist to validate every decision table:<\/p>\n<ul>\n<li><strong>Completeness<\/strong>: Are all possible combinations of conditions included?<\/li>\n<li><strong>Consistency<\/strong>: Do any rules contradict each other? (e.g., same condition \u2192 different actions)<\/li>\n<li><strong>Redundancy<\/strong>: Are any rules unnecessary because another rule already covers them?<\/li>\n<li><strong>Clarity<\/strong>: Are conditions and actions unambiguous? Avoid phrases like \u201cand so on\u201d or \u201cetc.\u201d<\/li>\n<li><strong>Traceability<\/strong>: Can you map each rule back to a user story or requirement?<\/li>\n<\/ul>\n<p>Run this checklist with your team at sprint review. It\u2019s not just about catching bugs\u2014it\u2019s about building trust in your logic.<\/p>\n<h2>Best Practices for Agile Teams<\/h2>\n<p>Decision tables agile work best when integrated into the team\u2019s culture, not treated as a one-off exercise.<\/p>\n<p>Here are my top recommendations:<\/p>\n<ol>\n<li><strong>Start small<\/strong>: Use decision tables for high-risk or high-impact rules, not every story.<\/li>\n<li><strong>Use visual collaboration<\/strong>: Share tables in your product backlog or sprint board. Use color-coding for rule priority or status.<\/li>\n<li><strong>Version control logic<\/strong>: Treat decision tables like code. Store them in your repository with version history.<\/li>\n<li><strong>Review with QA<\/strong>: Have testers validate rules against test cases. This ensures traceability and coverage.<\/li>\n<li><strong>Automate when possible<\/strong>: Use rule engines (like Drools or OpenRules) to run decision tables at scale.<\/li>\n<\/ol>\n<p>These practices turn decision tables from documentation into living artifacts\u2014part of the product, not just a side note.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>How do decision tables in scrum improve sprint planning?<\/h3>\n<p>They clarify what \u201cdone\u201d means. By mapping all possible condition combinations, teams can estimate effort more accurately and avoid last-minute surprises.<\/p>\n<h3>Can decision tables agile handle complex, multi-level logic?<\/h3>\n<p>Yes. Break complex logic into modular tables. Use references to link them. This keeps the main table readable and reusable.<\/p>\n<h3>Do decision tables agile replace user stories?<\/h3>\n<p>No. They enhance user stories. A user story defines *what* the system should do. A decision table defines *how* it responds under every condition.<\/p>\n<h3>How do I ensure teams adopt decision tables agile?<\/h3>\n<p>Start with high-impact stories. Involve the team in building the table. Show how it reduces rework and clarifies acceptance. Make it part of your sprint review.<\/p>\n<h3>Are decision tables agile suitable for non-technical teams?<\/h3>\n<p>Yes. With clear, plain-language conditions and actions, even product owners and business analysts can contribute and validate logic. Use visual aids and walkthroughs to build confidence.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>\u201cBreak down complex logic into simple, testable statements.\u201d This advice appears in dozens of agile guides. It sounds practical\u2014until you realize it\u2019s often incomplete. The real challenge isn\u2019t simplicity, but completeness. In my 20 years of modeling business logic, I\u2019ve seen teams miss critical edge cases because they treated logic as narrative, not structure. Decision [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":855,"menu_order":0,"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":"default","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"set","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-856","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>Decision Tables Agile: Mastering Logic in Scrum<\/title>\n<meta name=\"description\" content=\"Use decision tables agile to ensure logical completeness in user stories, acceptance criteria, and sprint planning. Learn agile modeling techniques for precise, maintainable decision logic in Scrum environments.\" \/>\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\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-agile\/\" \/>\n<meta property=\"og:locale\" content=\"es_ES\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Decision Tables Agile: Mastering Logic in Scrum\" \/>\n<meta property=\"og:description\" content=\"Use decision tables agile to ensure logical completeness in user stories, acceptance criteria, and sprint planning. Learn agile modeling techniques for precise, maintainable decision logic in Scrum environments.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/es\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-agile\/\" \/>\n<meta property=\"og:site_name\" content=\"Visual Paradigm Skills Espa\u00f1ol\" \/>\n<meta property=\"article:modified_time\" content=\"2026-03-02T09:06:57+00:00\" \/>\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\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-agile\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/es\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-agile\/\",\"name\":\"Decision Tables Agile: Mastering Logic in Scrum\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/es\/#website\"},\"datePublished\":\"2026-02-25T10:25:43+00:00\",\"dateModified\":\"2026-03-02T09:06:57+00:00\",\"description\":\"Use decision tables agile to ensure logical completeness in user stories, acceptance criteria, and sprint planning. Learn agile modeling techniques for precise, maintainable decision logic in Scrum environments.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/es\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-agile\/#breadcrumb\"},\"inLanguage\":\"es\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/es\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-agile\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/es\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-agile\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/es\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Decision Tables Explained: From Concept to Implementation\",\"item\":\"https:\/\/skills.visual-paradigm.com\/es\/docs\/decision-tables-explained\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Modern Extensions and Emerging Practices\",\"item\":\"https:\/\/skills.visual-paradigm.com\/es\/docs\/decision-tables-explained\/applied-decision-table-modeling\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Decision Tables in Agile and Scrum Environments\"}]},{\"@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":"Decision Tables Agile: Mastering Logic in Scrum","description":"Use decision tables agile to ensure logical completeness in user stories, acceptance criteria, and sprint planning. Learn agile modeling techniques for precise, maintainable decision logic in Scrum environments.","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\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-agile\/","og_locale":"es_ES","og_type":"article","og_title":"Decision Tables Agile: Mastering Logic in Scrum","og_description":"Use decision tables agile to ensure logical completeness in user stories, acceptance criteria, and sprint planning. Learn agile modeling techniques for precise, maintainable decision logic in Scrum environments.","og_url":"https:\/\/skills.visual-paradigm.com\/es\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-agile\/","og_site_name":"Visual Paradigm Skills Espa\u00f1ol","article_modified_time":"2026-03-02T09:06:57+00:00","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\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-agile\/","url":"https:\/\/skills.visual-paradigm.com\/es\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-agile\/","name":"Decision Tables Agile: Mastering Logic in Scrum","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/es\/#website"},"datePublished":"2026-02-25T10:25:43+00:00","dateModified":"2026-03-02T09:06:57+00:00","description":"Use decision tables agile to ensure logical completeness in user stories, acceptance criteria, and sprint planning. Learn agile modeling techniques for precise, maintainable decision logic in Scrum environments.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/es\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-agile\/#breadcrumb"},"inLanguage":"es","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/es\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-agile\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/es\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-agile\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/es\/"},{"@type":"ListItem","position":2,"name":"Decision Tables Explained: From Concept to Implementation","item":"https:\/\/skills.visual-paradigm.com\/es\/docs\/decision-tables-explained\/"},{"@type":"ListItem","position":3,"name":"Modern Extensions and Emerging Practices","item":"https:\/\/skills.visual-paradigm.com\/es\/docs\/decision-tables-explained\/applied-decision-table-modeling\/"},{"@type":"ListItem","position":4,"name":"Decision Tables in Agile and Scrum Environments"}]},{"@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\/856","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":1,"href":"https:\/\/skills.visual-paradigm.com\/es\/wp-json\/wp\/v2\/docs\/856\/revisions"}],"predecessor-version":[{"id":2392,"href":"https:\/\/skills.visual-paradigm.com\/es\/wp-json\/wp\/v2\/docs\/856\/revisions\/2392"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/es\/wp-json\/wp\/v2\/docs\/855"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/es\/wp-json\/wp\/v2\/media?parent=856"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/es\/wp-json\/wp\/v2\/doc_tag?post=856"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}