{"id":1794,"date":"2026-02-25T10:46:08","date_gmt":"2026-02-25T10:46:08","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/nfr-user-stories-embedding-non-functional-requirements\/"},"modified":"2026-02-25T10:46:08","modified_gmt":"2026-02-25T10:46:08","slug":"nfr-user-stories-embedding-non-functional-requirements","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/nfr-user-stories-embedding-non-functional-requirements\/","title":{"rendered":"Integrating Non-Functional Requirements (NFRs) into Stories"},"content":{"rendered":"<p>When teams begin to scale user stories, a recurring pattern emerges: acceptance criteria grow long, brittle, and disconnected from actual user value. The root cause? NFRs\u2014often implicit or buried in technical specs\u2014are left out until late, creating rework, integration delays, and misaligned delivery. This isn\u2019t a documentation problem. It\u2019s a modeling problem.<\/p>\n<p>Non-functional requirements (NFRs) like performance, security, and scalability aren\u2019t add-ons. They\u2019re part of the story. The solution isn\u2019t to write more documentation, but to reframe how we express them. In this chapter, I\u2019ll show how to embed performance, security, and resilience directly into user stories\u2014using acceptance criteria, architectural stories, and shared language\u2014so teams can build with confidence, even across multiple squads.<\/p>\n<p>You\u2019ll learn how to move beyond \u201cthe system must be secure\u201d and write actionable, testable NFR user stories. You\u2019ll gain techniques to align technical quality with business value, avoiding the trap of \u201cagile but brittle\u201d systems. This is not about adding more steps. It\u2019s about making quality part of the story.<\/p>\n<h2>Why NFRs Break Agile Flow<\/h2>\n<p>At scale, teams often treat NFRs as technical debt\u2014not part of the user experience. A story like \u201cAs a customer, I want to log in quickly\u201d may have no performance criteria. That leads to a dangerous gap.<\/p>\n<p>When performance and security are defined only in architectural documents, teams lose context. Acceptance tests fail during integration. Delivery blocks. The illusion of agility collapses.<\/p>\n<p>My experience tells me: if a feature isn\u2019t testable for performance or security at the story level, it\u2019s not truly ready. The fix is not to add more process. It\u2019s to reframe the story.<\/p>\n<h3>Common Pitfalls in NFR Integration<\/h3>\n<ul>\n<li>Deferring NFRs to technical spikes or late in the cycle.<\/li>\n<li>Using vague language: \u201cthe system must be fast\u201d or \u201cit should be secure.\u201d<\/li>\n<li>Defining acceptance criteria in isolation, without cross-functional alignment.<\/li>\n<li>Assigning ownership of NFRs only to architects or DevOps teams.<\/li>\n<\/ul>\n<p>These aren\u2019t just inefficiencies. They\u2019re systemic risks. The goal isn\u2019t to write more stories. It\u2019s to write better ones\u2014where quality is not a phase, but a feature.<\/p>\n<h2>Embedding NFRs Through Acceptance Criteria<\/h2>\n<p>Acceptance criteria are where non-functional requirements earn their place in the story. If we treat them as optional or secondary, we\u2019ve already failed.<\/p>\n<p>Start with the story. Then ask: what does \u201cworking\u201d mean for this user? Performance, security, availability\u2014these aren\u2019t exceptions. They\u2019re expectations.<\/p>\n<h3>Practical Patterns for NFR Acceptance Criteria<\/h3>\n<p>Consider this story:<\/p>\n<p><em>As a user, I want to access my account dashboard within 2 seconds so I can make quick decisions.<\/em><\/p>\n<p>Now write acceptance criteria that reflect performance:<\/p>\n<ol>\n<li>When I load the dashboard, the first meaningful content appears in under 1.5 seconds.<\/li>\n<li>95% of requests must complete within 2 seconds under normal load.<\/li>\n<li>Page load time must not exceed 4 seconds under peak traffic (5,000 concurrent users).<\/li>\n<\/ol>\n<p>Now consider security:<\/p>\n<ol start=\"4\">\n<li>The dashboard must only load after successful authentication using OAuth 2.0 with short-lived tokens.<\/li>\n<li>Session expiration must occur after 15 minutes of inactivity.<\/li>\n<li>Any failed login attempt must trigger a 5-second delay before retry.<\/li>\n<\/ol>\n<p>These aren\u2019t \u201cnice-to-haves.\u201d They\u2019re part of the user\u2019s experience. If the system can\u2019t deliver under load, the story isn\u2019t complete\u2014even if it \u201cworks\u201d in a dev environment.<\/p>\n<p>For <strong>non functional agile<\/strong> teams, the key isn\u2019t adding more rows to a spreadsheet. It\u2019s asking: what does this story mean to the user in real-world conditions?<\/p>\n<h2>Architectural Stories: Making NFRs First-Class Citizens<\/h2>\n<p>Some NFRs\u2014like scalability, resilience, or observability\u2014can\u2019t be tested in a single story. They need dedicated architectural stories.<\/p>\n<p>These aren\u2019t technical specs. They\u2019re stories. They have a user, an outcome, and acceptance criteria.<\/p>\n<p>Example:<\/p>\n<p><em>As a system, I want to handle 10,000 concurrent requests per minute so that users don\u2019t experience downtime during peak use.<\/em><\/p>\n<p>Acceptance criteria:<\/p>\n<ul>\n<li>99.9% uptime over a 30-day period under sustained load.<\/li>\n<li>Auto-scaling triggers when CPU exceeds 80% for more than 2 minutes.<\/li>\n<li>Latency increases by no more than 150ms under 10,000 RPS.<\/li>\n<\/ul>\n<p>This story isn\u2019t written for developers. It\u2019s written for the system\u2014to define its behavior in production. But it serves the user experience.<\/p>\n<p>These architectural stories belong in the product backlog. They\u2019re not hidden in technical epics. They\u2019re part of the value stream.<\/p>\n<h3>When to Use Architectural Stories<\/h3>\n<p>Use architectural stories when:<\/p>\n<ul>\n<li>The NFR impacts multiple teams or systems.<\/li>\n<li>It defines a foundational capability (e.g., observability, audit logging).<\/li>\n<li>It\u2019s not tied to a specific feature but enables many.<\/li>\n<li>It needs to be tested at scale.<\/li>\n<\/ul>\n<p>They\u2019re not a replacement for feature-level acceptance criteria. They\u2019re a supplement\u2014ensuring quality is baked in, not bolted on.<\/p>\n<h2>Guiding Principles for NFR User Stories<\/h2>\n<p>Over the years, I\u2019ve seen teams struggle with consistency. The key is not rules. It\u2019s clarity. These principles have helped dozens of teams align on NFRs without bureaucracy.<\/p>\n<h3>1. Treat NFRs as User-Centric<\/h3>\n<p>Frame every NFR in terms of user impact. \u201cThe system must be secure\u201d becomes \u201cAs a user, I want my data protected from unauthorized access so I can trust the platform.\u201d<\/p>\n<p>Even if the user doesn\u2019t \u201cfeel\u201d security, they trust the system more when it behaves reliably under attack.<\/p>\n<h3>2. Use Measurable, Testable Criteria<\/h3>\n<p>Never accept \u201cshould be fast\u201d or \u201cmust be reliable.\u201d Instead, use time, load, error rate, or availability.<\/p>\n<p>Example: \u201cThe search must return results in under 800ms for 95% of queries.\u201d<\/p>\n<h3>3. Split Complex NFRs into Smaller Stories<\/h3>\n<p>High-load performance or multi-region availability can\u2019t be a single story. Break them down.<\/p>\n<ul>\n<li>As a user, I want search to respond within 500ms so I can browse quickly.<\/li>\n<li>As a system, I want to scale across three regions so I can serve users globally.<\/li>\n<li>As a user, I want search to remain available even during a regional outage so I\u2019m not blocked.<\/li>\n<\/ul>\n<p>Each story can then be tested independently, and teams can deliver in stages.<\/p>\n<h3>4. Involve All Roles Early<\/h3>\n<p>Don\u2019t wait for QA or DevOps to review acceptance criteria. Include them in refinement.<\/p>\n<p>When security or performance is in question, the architect, developer, and QA should co-own the criteria. This builds shared understanding.<\/p>\n<p>For <strong>performance security user stories<\/strong>, this means the story isn\u2019t \u201cdone\u201d until all three agree.<\/p>\n<h2>Sample NFR Story Template<\/h2>\n<p>Use this to standardize how teams write NFR stories:<\/p>\n<pre><code>As a [user role],\nI want [functionality] \nso that [benefit to user],\nand the system must [measurable NFR criterion].\n\nAcceptance Criteria:\n- [Criterion 1: measurable, e.g., \"load time under 1.5s\"]\n- [Criterion 2: e.g., \"handle 5000 RPS with 0.1% error rate\"]\n- [Criterion 3: e.g., \"support 99.95% uptime\"]<\/code><\/pre>\n<p>Apply this across features. It keeps conversations focused, measurable, and aligned with real user outcomes.<\/p>\n<h2>Comparison: NFR Integration Methods<\/h2>\n<table>\n<thead>\n<tr>\n<th>Method<\/th>\n<th>When to Use<\/th>\n<th>Pros<\/th>\n<th>Cons<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Acceptance Criteria in User Story<\/td>\n<td>Simple, measurable NFRs (e.g., response time, login timeout)<\/td>\n<td>Direct, testable, team-aligned<\/td>\n<td>Not suitable for complex, cross-cutting concerns<\/td>\n<\/tr>\n<tr>\n<td>Architectural Story<\/td>\n<td>Scalability, observability, resilience, audit trails<\/td>\n<td>Enables cross-team alignment, testable at scale<\/td>\n<td>May require higher-level ownership<\/td>\n<\/tr>\n<tr>\n<td>Shared Definition of Done (DoD)<\/td>\n<td>Standardized NFRs (e.g., all stories must pass security scan)<\/td>\n<td>Ensures consistency across teams<\/td>\n<td>May lack specificity for complex cases<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Use the table above to decide which approach fits your context. The best teams combine all three\u2014using the right method for the right NFR.<\/p>\n<h2>Final Thoughts<\/h2>\n<p>Non-functional requirements aren\u2019t technical details. They\u2019re user expectations. When teams write NFR user stories, they\u2019re not just building software\u2014they\u2019re building trust.<\/p>\n<p>Don\u2019t wait for the last sprint. Don\u2019t defer to \u201ctechnical debt.\u201d Integrate performance, security, and resilience into the story from day one. Use measurable acceptance criteria. Split complex requirements into architectural stories. Involve all roles in defining what \u201cworking\u201d means.<\/p>\n<p>For any team serious about <strong>non functional agile<\/strong>, this is how true agility begins. You\u2019re not scaling documentation. You\u2019re scaling understanding.<\/p>\n<p>Now go back to your backlog. Find one story where the NFR is missing. Rewrite it. Test it. Share it. That\u2019s how real progress happens.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>How do I write NFRs without making stories too long?<\/h3>\n<p>Focus on the user impact. Use concise, measurable criteria. For example: \u201cThe login page must load under 1.5 seconds for 95% of users.\u201d Avoid technical jargon. If a criterion needs deep detail, split it into an architectural story.<\/p>\n<h3>Can NFRs be part of a feature or must they be standalone?<\/h3>\n<p>NFRs can be part of a feature story if they\u2019re directly tied to user value (e.g., \u201cI want fast response times\u201d). But for cross-cutting concerns like scalability or observability, use architectural stories. This separates concerns and enables independent delivery and testing.<\/p>\n<h3>Who owns the NFR acceptance criteria?<\/h3>\n<p>Ownership is shared. The product owner defines the business need. The developer ensures feasibility. The QA designs the test. The architect validates the design. All collaborate to define what \u201cworking\u201d means.<\/p>\n<h3>How do I handle NFRs in a multi-team environment?<\/h3>\n<p>Use shared acceptance criteria or architectural stories in the program backlog. Ensure teams coordinate through PI planning, dependency mapping, and shared DoD. Use visual models to track NFR status across teams.<\/p>\n<h3>What if a team says security isn\u2019t their responsibility?<\/h3>\n<p>It is. Every story impacts security. If a team says it\u2019s not their job, it\u2019s a cultural red flag. Reiterate that security is a feature. Reframe the story so the team owns the outcome. Use shared DoD to enforce it.<\/p>\n<h3>How can I ensure NFRs are tested automatically?<\/h3>\n<p>Integrate performance and security tests into CI\/CD pipelines. Use tools like k6, Postman, or OWASP ZAP. Link the test results to the story with traceability. If a test fails, the story isn\u2019t done.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>When teams begin to scale user stories, a recurring pattern emerges: acceptance criteria grow long, brittle, and disconnected from actual user value. The root cause? NFRs\u2014often implicit or buried in technical specs\u2014are left out until late, creating rework, integration delays, and misaligned delivery. This isn\u2019t a documentation problem. It\u2019s a modeling problem. Non-functional requirements (NFRs) [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":1792,"menu_order":1,"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-1794","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>NFR User Stories: Embedding Non-Functional Requirements<\/title>\n<meta name=\"description\" content=\"Learn how to effectively integrate non-functional requirements into user stories using practical patterns, acceptance criteria, and architectural stories for agile teams at scale.\" \/>\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\/pl\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/nfr-user-stories-embedding-non-functional-requirements\/\" \/>\n<meta property=\"og:locale\" content=\"pl_PL\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"NFR User Stories: Embedding Non-Functional Requirements\" \/>\n<meta property=\"og:description\" content=\"Learn how to effectively integrate non-functional requirements into user stories using practical patterns, acceptance criteria, and architectural stories for agile teams at scale.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/nfr-user-stories-embedding-non-functional-requirements\/\" \/>\n<meta property=\"og:site_name\" content=\"Visual Paradigm Skills Polski\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Szacowany czas czytania\" \/>\n\t<meta name=\"twitter:data1\" content=\"8 minut\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/nfr-user-stories-embedding-non-functional-requirements\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/nfr-user-stories-embedding-non-functional-requirements\/\",\"name\":\"NFR User Stories: Embedding Non-Functional Requirements\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/#website\"},\"datePublished\":\"2026-02-25T10:46:08+00:00\",\"description\":\"Learn how to effectively integrate non-functional requirements into user stories using practical patterns, acceptance criteria, and architectural stories for agile teams at scale.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/nfr-user-stories-embedding-non-functional-requirements\/#breadcrumb\"},\"inLanguage\":\"pl-PL\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/nfr-user-stories-embedding-non-functional-requirements\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/nfr-user-stories-embedding-non-functional-requirements\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pl\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"User Story Techniques for Large-Scale Agile Projects\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/user-story-techniques-large-scale-agile\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Advanced Story Patterns for Enterprises\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pl\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Integrating Non-Functional Requirements (NFRs) into Stories\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/#website\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pl\/\",\"name\":\"Visual Paradigm Skills Polski\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/skills.visual-paradigm.com\/pl\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"pl-PL\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/#organization\",\"name\":\"Visual Paradigm Skills Polski\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pl\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"pl-PL\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pl\/wp-content\/uploads\/sites\/8\/2026\/02\/favicon.svg\",\"contentUrl\":\"https:\/\/skills.visual-paradigm.com\/pl\/wp-content\/uploads\/sites\/8\/2026\/02\/favicon.svg\",\"width\":70,\"height\":70,\"caption\":\"Visual Paradigm Skills Polski\"},\"image\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pl\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"NFR User Stories: Embedding Non-Functional Requirements","description":"Learn how to effectively integrate non-functional requirements into user stories using practical patterns, acceptance criteria, and architectural stories for agile teams at scale.","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\/pl\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/nfr-user-stories-embedding-non-functional-requirements\/","og_locale":"pl_PL","og_type":"article","og_title":"NFR User Stories: Embedding Non-Functional Requirements","og_description":"Learn how to effectively integrate non-functional requirements into user stories using practical patterns, acceptance criteria, and architectural stories for agile teams at scale.","og_url":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/nfr-user-stories-embedding-non-functional-requirements\/","og_site_name":"Visual Paradigm Skills Polski","twitter_card":"summary_large_image","twitter_misc":{"Szacowany czas czytania":"8 minut"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/nfr-user-stories-embedding-non-functional-requirements\/","url":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/nfr-user-stories-embedding-non-functional-requirements\/","name":"NFR User Stories: Embedding Non-Functional Requirements","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/pl\/#website"},"datePublished":"2026-02-25T10:46:08+00:00","description":"Learn how to effectively integrate non-functional requirements into user stories using practical patterns, acceptance criteria, and architectural stories for agile teams at scale.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/nfr-user-stories-embedding-non-functional-requirements\/#breadcrumb"},"inLanguage":"pl-PL","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/pl\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/nfr-user-stories-embedding-non-functional-requirements\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/nfr-user-stories-embedding-non-functional-requirements\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/pl\/"},{"@type":"ListItem","position":2,"name":"User Story Techniques for Large-Scale Agile Projects","item":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/user-story-techniques-large-scale-agile\/"},{"@type":"ListItem","position":3,"name":"Advanced Story Patterns for Enterprises","item":"https:\/\/skills.visual-paradigm.com\/pl\/docs\/user-story-techniques-large-scale-agile\/advanced-enterprise-story-patterns\/"},{"@type":"ListItem","position":4,"name":"Integrating Non-Functional Requirements (NFRs) into Stories"}]},{"@type":"WebSite","@id":"https:\/\/skills.visual-paradigm.com\/pl\/#website","url":"https:\/\/skills.visual-paradigm.com\/pl\/","name":"Visual Paradigm Skills Polski","description":"","publisher":{"@id":"https:\/\/skills.visual-paradigm.com\/pl\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/skills.visual-paradigm.com\/pl\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"pl-PL"},{"@type":"Organization","@id":"https:\/\/skills.visual-paradigm.com\/pl\/#organization","name":"Visual Paradigm Skills Polski","url":"https:\/\/skills.visual-paradigm.com\/pl\/","logo":{"@type":"ImageObject","inLanguage":"pl-PL","@id":"https:\/\/skills.visual-paradigm.com\/pl\/#\/schema\/logo\/image\/","url":"https:\/\/skills.visual-paradigm.com\/pl\/wp-content\/uploads\/sites\/8\/2026\/02\/favicon.svg","contentUrl":"https:\/\/skills.visual-paradigm.com\/pl\/wp-content\/uploads\/sites\/8\/2026\/02\/favicon.svg","width":70,"height":70,"caption":"Visual Paradigm Skills Polski"},"image":{"@id":"https:\/\/skills.visual-paradigm.com\/pl\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/docs\/1794","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/docs"}],"about":[{"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/types\/docs"}],"author":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/docs\/1794\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/docs\/1792"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/media?parent=1794"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pl\/wp-json\/wp\/v2\/doc_tag?post=1794"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}