How to refer to functional requirement specifications (FRS) from user stories? The 2019 Stack Overflow Developer Survey Results Are In Announcing the arrival of Valued Associate #679: Cesar Manara Planned maintenance scheduled April 17/18, 2019 at 00:00UTC (8:00pm US/Eastern)What's the name for the issue where a customer cannot articulate his/her requirements before seeing the finished software?Confusion about user story in project requirement documentUser story conversation vs. scope creepUser stories vs Functional specificationsUser Interface Requirements in User StoriesSplitting user storiesHow to handle unfinished user stories?How to write implementing HTTPS as a user story?Specifications in spreadsheets vs. stories in JIRADetect undiscovered user storiesWhat does a QA team do during the development phase of a sprint in Agile Scrum?
Is 'stolen' appropriate word?
What information about me do stores get via my credit card?
Simulating Exploding Dice
Variable with quotation marks "$()"
Working through the single responsibility principle (SRP) in Python when calls are expensive
Is it ethical to upload a automatically generated paper to a non peer-reviewed site as part of a larger research?
When did F become S? Why?
Why not take a picture of a closer black hole?
Match Roman Numerals
For what reasons would an animal species NOT cross a *horizontal* land bridge?
Are spiders unable to hurt humans, especially very small spiders?
Accepted by European university, rejected by all American ones I applied to? Possible reasons?
Could an empire control the whole planet with today's comunication methods?
Drawing vertical/oblique lines in Metrical tree (tikz-qtree, tipa)
Homework question about an engine pulling a train
Sub-subscripts in strings cause different spacings than subscripts
Can withdrawing asylum be illegal?
What to do when moving next to a bird sanctuary with a loosely-domesticated cat?
Do warforged have souls?
Can I visit the Trinity College (Cambridge) library and see some of their rare books
Example of compact Riemannian manifold with only one geodesic.
Can each chord in a progression create its own key?
Circular reasoning in L'Hopital's rule
Do working physicists consider Newtonian mechanics to be "falsified"?
How to refer to functional requirement specifications (FRS) from user stories?
The 2019 Stack Overflow Developer Survey Results Are In
Announcing the arrival of Valued Associate #679: Cesar Manara
Planned maintenance scheduled April 17/18, 2019 at 00:00UTC (8:00pm US/Eastern)What's the name for the issue where a customer cannot articulate his/her requirements before seeing the finished software?Confusion about user story in project requirement documentUser story conversation vs. scope creepUser stories vs Functional specificationsUser Interface Requirements in User StoriesSplitting user storiesHow to handle unfinished user stories?How to write implementing HTTPS as a user story?Specifications in spreadsheets vs. stories in JIRADetect undiscovered user storiesWhat does a QA team do during the development phase of a sprint in Agile Scrum?
Let's consider a simple story for a user authentication screen:
As a user,
I want to be able to login with my username and password
so that I can do xyz.
This looks good, but all of the details related to what should happen when the password is incorrect, how many retries should be allowed, validations, and a bunch of other stuff that should go in with that story are missing.
Where should all that information go in an agile Scrum setup? Is it an FRS (or any other equivalent monolithic document containing details of all functional specs)? If yes, given there will be hundreds or thousands of these tiny stories, how should references to their corresponding FRS sections kept in sync with each other? How best to manage this level of detail in an agile Scrum world?
scrum agile user-stories documentation
New contributor
add a comment |
Let's consider a simple story for a user authentication screen:
As a user,
I want to be able to login with my username and password
so that I can do xyz.
This looks good, but all of the details related to what should happen when the password is incorrect, how many retries should be allowed, validations, and a bunch of other stuff that should go in with that story are missing.
Where should all that information go in an agile Scrum setup? Is it an FRS (or any other equivalent monolithic document containing details of all functional specs)? If yes, given there will be hundreds or thousands of these tiny stories, how should references to their corresponding FRS sections kept in sync with each other? How best to manage this level of detail in an agile Scrum world?
scrum agile user-stories documentation
New contributor
1
On a side note, having "hundreds or thousands of tiny stories" is generally an anti-pattern in itself. Most of what you're envisioning as stories are better captured in tests, the Definition of Done, or items on the Sprint Backlog (if they have to be captured at all). User story development is an art, not a science, so please browse the user-stories tag or read Mike Cohn's books on the subject for more thorough guidance on how to find the right balance of granularity for your project.
– Todd A. Jacobs♦
yesterday
add a comment |
Let's consider a simple story for a user authentication screen:
As a user,
I want to be able to login with my username and password
so that I can do xyz.
This looks good, but all of the details related to what should happen when the password is incorrect, how many retries should be allowed, validations, and a bunch of other stuff that should go in with that story are missing.
Where should all that information go in an agile Scrum setup? Is it an FRS (or any other equivalent monolithic document containing details of all functional specs)? If yes, given there will be hundreds or thousands of these tiny stories, how should references to their corresponding FRS sections kept in sync with each other? How best to manage this level of detail in an agile Scrum world?
scrum agile user-stories documentation
New contributor
Let's consider a simple story for a user authentication screen:
As a user,
I want to be able to login with my username and password
so that I can do xyz.
This looks good, but all of the details related to what should happen when the password is incorrect, how many retries should be allowed, validations, and a bunch of other stuff that should go in with that story are missing.
Where should all that information go in an agile Scrum setup? Is it an FRS (or any other equivalent monolithic document containing details of all functional specs)? If yes, given there will be hundreds or thousands of these tiny stories, how should references to their corresponding FRS sections kept in sync with each other? How best to manage this level of detail in an agile Scrum world?
scrum agile user-stories documentation
scrum agile user-stories documentation
New contributor
New contributor
edited yesterday
Todd A. Jacobs♦
34k333121
34k333121
New contributor
asked 2 days ago
AchillesAchilles
1262
1262
New contributor
New contributor
1
On a side note, having "hundreds or thousands of tiny stories" is generally an anti-pattern in itself. Most of what you're envisioning as stories are better captured in tests, the Definition of Done, or items on the Sprint Backlog (if they have to be captured at all). User story development is an art, not a science, so please browse the user-stories tag or read Mike Cohn's books on the subject for more thorough guidance on how to find the right balance of granularity for your project.
– Todd A. Jacobs♦
yesterday
add a comment |
1
On a side note, having "hundreds or thousands of tiny stories" is generally an anti-pattern in itself. Most of what you're envisioning as stories are better captured in tests, the Definition of Done, or items on the Sprint Backlog (if they have to be captured at all). User story development is an art, not a science, so please browse the user-stories tag or read Mike Cohn's books on the subject for more thorough guidance on how to find the right balance of granularity for your project.
– Todd A. Jacobs♦
yesterday
1
1
On a side note, having "hundreds or thousands of tiny stories" is generally an anti-pattern in itself. Most of what you're envisioning as stories are better captured in tests, the Definition of Done, or items on the Sprint Backlog (if they have to be captured at all). User story development is an art, not a science, so please browse the user-stories tag or read Mike Cohn's books on the subject for more thorough guidance on how to find the right balance of granularity for your project.
– Todd A. Jacobs♦
yesterday
On a side note, having "hundreds or thousands of tiny stories" is generally an anti-pattern in itself. Most of what you're envisioning as stories are better captured in tests, the Definition of Done, or items on the Sprint Backlog (if they have to be captured at all). User story development is an art, not a science, so please browse the user-stories tag or read Mike Cohn's books on the subject for more thorough guidance on how to find the right balance of granularity for your project.
– Todd A. Jacobs♦
yesterday
add a comment |
4 Answers
4
active
oldest
votes
You've basically hit on the purpose of user stories. You see, user stories arose when we had large requirements documents that had all of the details the dev team could possibly need to develop the software. The problem with this is that those details take a long time to document and it turns out, they often aren't what the user wants (or at least miss the mark). Now all of that time has been wasted. Instead, we write a user story gives us just enough information to have a conversation with the person who wrote it. The dev team can ask questions and get a better understanding of their needs, then build something that meets them. They'll write their notes someplace and depending on your application, it might even make sense that those are stored in a very specific place. So, the purpose of user stories was to get away from monolithic documents and move to personal conversations. If you are tying a user story back to details in a large requirements document, you've eliminated the value of user stories.
add a comment |
TL;DR
The short answer is that you don't. Big, upfront planning is orthogonal to agile development. Instead, you should focus on iterative and incremental development with tight feedback loops to ensure that you're building the right things and embracing change throughout the project's life cycle.
Big, Upfront Requirements an Anti-Pattern
Doing detailed or large-scale requirements at the inception of a project is an agile anti-pattern. In particular, the Manifesto for Agile Software Development values:
Working software over comprehensive documentation[.]
Likewise, Scrum Theory explicitly avoids the use of fixed, upfront planning:
Scrum employs an iterative, incremental approach to optimize predictability and control risk.
While there is nothing stopping you from linking user stories or other types of Product Backlog Items to functional requirements, doing so is often a "project smell" that you're fixing scope, which is ideally the movable part of the Iron Triangle in Scrum. Furthermore, it's often an indication that you're making implementation decisions too early in the process. Lean practices require that you make architectural and design decisions at the last responsible moment, which is almost never at the very beginning of a project when functional requirement specifications are usually gathered.
What to do Instead
Within the Scrum framework, you should be leveraging the framework to perform just-in-time planning at the proper level of granularity. In particular:
- Leverage Backlog Refinement to identify work that will likely be in scope for the next iteration, maximizing the amount of work not done.
- Use Sprint Planning to decompose work into tasks and deliverables only for the current increment, optimizing for just-in-time planning.
- Leave implementation details out of Product Backlog and (most) Sprint Backlog items, allowing for greater flexibility.
- Gather feedback from stakeholders during the Sprint Review to identify changes and refinements to be treated as new work, allowing the project to continually evolve to meet changing market demands and to take advantage of lessons learned.
While not required by Scrum, agile practices generally require integrating test-driven design or behavior-driven development (often in collaboration with stakeholders or customers) to ensure that any functional requirements in scope for the current iteration are well-defined and testable. This type of "living documentation" is often more useful, more accurate, more maintainable, and more effective than typical functional requirements documents.
This appears to be only a partial answer. If you don't write a large requirements document, where (and when) do you take note of those pesky details like number of login attempts and required password strength. Those are not implementation details that you can completely leave out.
– Bart van Ingen Schenau
yesterday
@BartvanIngenSchenau "Pesky details" should be driven out empirically. Simple or obvious ones are generally captured in executable tests when a feature comes into scope. Others will be discovered through the inspect-and-adapt cycle, and become refinements captured as new work for future iterations. The whole point of many agile practices is to avoid over-constraining the solution space and encourage emergent design, which is why you should not spec out implementation details until the last responsible moment.
– Todd A. Jacobs♦
yesterday
add a comment |
As said by others, details should be clarified at the last responsible moment, sometimes at the moment of implementation in close collaboration between developers and e.g. business people or UX experts. However, specific information could be noted as acceptance criteria. More general and repeating criteria may be better placed within the team's (or organizations) Definition of 'Done'.
For acceptance criteria you may also want to take a look at a syntax like Gherkin
-- and you may want to automate testing with things like Cucumber as a living, more value-adding documentation and base for regression testing.
New contributor
add a comment |
I think part of the problem is that this:
login with my username and password
is not a requirement. It's a design choice masquerading as a requirement. The real requirement is something like: "As a user I need to (securely and uniquely) authenticate with the system so that I can ..." Choosing username and password immediately rules out other, lower friction, means of authentication. Already logged in to Active Directory/G Suite/Office 365/another Oauth provider? Can we use that? What about facial recognition and fingerprint? Is that sufficient?
Keep this in mind as you go through your user stories. Are they telling you how something should be done instead of what needs to be done? Quite often this is OK; they're expanding on/clarifying earlier design choices. But sometimes it's worth taking a step back, asking yourself what problem are they really solving, and is there a better way?
New contributor
add a comment |
Your Answer
StackExchange.ready(function()
var channelOptions =
tags: "".split(" "),
id: "208"
;
initTagRenderer("".split(" "), "".split(" "), channelOptions);
StackExchange.using("externalEditor", function()
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled)
StackExchange.using("snippets", function()
createEditor();
);
else
createEditor();
);
function createEditor()
StackExchange.prepareEditor(
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: false,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: null,
bindNavPrevention: true,
postfix: "",
imageUploader:
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
,
noCode: true, onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
);
);
Achilles is a new contributor. Be nice, and check out our Code of Conduct.
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function ()
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fpm.stackexchange.com%2fquestions%2f26166%2fhow-to-refer-to-functional-requirement-specifications-frs-from-user-stories%23new-answer', 'question_page');
);
Post as a guest
Required, but never shown
4 Answers
4
active
oldest
votes
4 Answers
4
active
oldest
votes
active
oldest
votes
active
oldest
votes
You've basically hit on the purpose of user stories. You see, user stories arose when we had large requirements documents that had all of the details the dev team could possibly need to develop the software. The problem with this is that those details take a long time to document and it turns out, they often aren't what the user wants (or at least miss the mark). Now all of that time has been wasted. Instead, we write a user story gives us just enough information to have a conversation with the person who wrote it. The dev team can ask questions and get a better understanding of their needs, then build something that meets them. They'll write their notes someplace and depending on your application, it might even make sense that those are stored in a very specific place. So, the purpose of user stories was to get away from monolithic documents and move to personal conversations. If you are tying a user story back to details in a large requirements document, you've eliminated the value of user stories.
add a comment |
You've basically hit on the purpose of user stories. You see, user stories arose when we had large requirements documents that had all of the details the dev team could possibly need to develop the software. The problem with this is that those details take a long time to document and it turns out, they often aren't what the user wants (or at least miss the mark). Now all of that time has been wasted. Instead, we write a user story gives us just enough information to have a conversation with the person who wrote it. The dev team can ask questions and get a better understanding of their needs, then build something that meets them. They'll write their notes someplace and depending on your application, it might even make sense that those are stored in a very specific place. So, the purpose of user stories was to get away from monolithic documents and move to personal conversations. If you are tying a user story back to details in a large requirements document, you've eliminated the value of user stories.
add a comment |
You've basically hit on the purpose of user stories. You see, user stories arose when we had large requirements documents that had all of the details the dev team could possibly need to develop the software. The problem with this is that those details take a long time to document and it turns out, they often aren't what the user wants (or at least miss the mark). Now all of that time has been wasted. Instead, we write a user story gives us just enough information to have a conversation with the person who wrote it. The dev team can ask questions and get a better understanding of their needs, then build something that meets them. They'll write their notes someplace and depending on your application, it might even make sense that those are stored in a very specific place. So, the purpose of user stories was to get away from monolithic documents and move to personal conversations. If you are tying a user story back to details in a large requirements document, you've eliminated the value of user stories.
You've basically hit on the purpose of user stories. You see, user stories arose when we had large requirements documents that had all of the details the dev team could possibly need to develop the software. The problem with this is that those details take a long time to document and it turns out, they often aren't what the user wants (or at least miss the mark). Now all of that time has been wasted. Instead, we write a user story gives us just enough information to have a conversation with the person who wrote it. The dev team can ask questions and get a better understanding of their needs, then build something that meets them. They'll write their notes someplace and depending on your application, it might even make sense that those are stored in a very specific place. So, the purpose of user stories was to get away from monolithic documents and move to personal conversations. If you are tying a user story back to details in a large requirements document, you've eliminated the value of user stories.
answered 2 days ago
DanielDaniel
9,75321327
9,75321327
add a comment |
add a comment |
TL;DR
The short answer is that you don't. Big, upfront planning is orthogonal to agile development. Instead, you should focus on iterative and incremental development with tight feedback loops to ensure that you're building the right things and embracing change throughout the project's life cycle.
Big, Upfront Requirements an Anti-Pattern
Doing detailed or large-scale requirements at the inception of a project is an agile anti-pattern. In particular, the Manifesto for Agile Software Development values:
Working software over comprehensive documentation[.]
Likewise, Scrum Theory explicitly avoids the use of fixed, upfront planning:
Scrum employs an iterative, incremental approach to optimize predictability and control risk.
While there is nothing stopping you from linking user stories or other types of Product Backlog Items to functional requirements, doing so is often a "project smell" that you're fixing scope, which is ideally the movable part of the Iron Triangle in Scrum. Furthermore, it's often an indication that you're making implementation decisions too early in the process. Lean practices require that you make architectural and design decisions at the last responsible moment, which is almost never at the very beginning of a project when functional requirement specifications are usually gathered.
What to do Instead
Within the Scrum framework, you should be leveraging the framework to perform just-in-time planning at the proper level of granularity. In particular:
- Leverage Backlog Refinement to identify work that will likely be in scope for the next iteration, maximizing the amount of work not done.
- Use Sprint Planning to decompose work into tasks and deliverables only for the current increment, optimizing for just-in-time planning.
- Leave implementation details out of Product Backlog and (most) Sprint Backlog items, allowing for greater flexibility.
- Gather feedback from stakeholders during the Sprint Review to identify changes and refinements to be treated as new work, allowing the project to continually evolve to meet changing market demands and to take advantage of lessons learned.
While not required by Scrum, agile practices generally require integrating test-driven design or behavior-driven development (often in collaboration with stakeholders or customers) to ensure that any functional requirements in scope for the current iteration are well-defined and testable. This type of "living documentation" is often more useful, more accurate, more maintainable, and more effective than typical functional requirements documents.
This appears to be only a partial answer. If you don't write a large requirements document, where (and when) do you take note of those pesky details like number of login attempts and required password strength. Those are not implementation details that you can completely leave out.
– Bart van Ingen Schenau
yesterday
@BartvanIngenSchenau "Pesky details" should be driven out empirically. Simple or obvious ones are generally captured in executable tests when a feature comes into scope. Others will be discovered through the inspect-and-adapt cycle, and become refinements captured as new work for future iterations. The whole point of many agile practices is to avoid over-constraining the solution space and encourage emergent design, which is why you should not spec out implementation details until the last responsible moment.
– Todd A. Jacobs♦
yesterday
add a comment |
TL;DR
The short answer is that you don't. Big, upfront planning is orthogonal to agile development. Instead, you should focus on iterative and incremental development with tight feedback loops to ensure that you're building the right things and embracing change throughout the project's life cycle.
Big, Upfront Requirements an Anti-Pattern
Doing detailed or large-scale requirements at the inception of a project is an agile anti-pattern. In particular, the Manifesto for Agile Software Development values:
Working software over comprehensive documentation[.]
Likewise, Scrum Theory explicitly avoids the use of fixed, upfront planning:
Scrum employs an iterative, incremental approach to optimize predictability and control risk.
While there is nothing stopping you from linking user stories or other types of Product Backlog Items to functional requirements, doing so is often a "project smell" that you're fixing scope, which is ideally the movable part of the Iron Triangle in Scrum. Furthermore, it's often an indication that you're making implementation decisions too early in the process. Lean practices require that you make architectural and design decisions at the last responsible moment, which is almost never at the very beginning of a project when functional requirement specifications are usually gathered.
What to do Instead
Within the Scrum framework, you should be leveraging the framework to perform just-in-time planning at the proper level of granularity. In particular:
- Leverage Backlog Refinement to identify work that will likely be in scope for the next iteration, maximizing the amount of work not done.
- Use Sprint Planning to decompose work into tasks and deliverables only for the current increment, optimizing for just-in-time planning.
- Leave implementation details out of Product Backlog and (most) Sprint Backlog items, allowing for greater flexibility.
- Gather feedback from stakeholders during the Sprint Review to identify changes and refinements to be treated as new work, allowing the project to continually evolve to meet changing market demands and to take advantage of lessons learned.
While not required by Scrum, agile practices generally require integrating test-driven design or behavior-driven development (often in collaboration with stakeholders or customers) to ensure that any functional requirements in scope for the current iteration are well-defined and testable. This type of "living documentation" is often more useful, more accurate, more maintainable, and more effective than typical functional requirements documents.
This appears to be only a partial answer. If you don't write a large requirements document, where (and when) do you take note of those pesky details like number of login attempts and required password strength. Those are not implementation details that you can completely leave out.
– Bart van Ingen Schenau
yesterday
@BartvanIngenSchenau "Pesky details" should be driven out empirically. Simple or obvious ones are generally captured in executable tests when a feature comes into scope. Others will be discovered through the inspect-and-adapt cycle, and become refinements captured as new work for future iterations. The whole point of many agile practices is to avoid over-constraining the solution space and encourage emergent design, which is why you should not spec out implementation details until the last responsible moment.
– Todd A. Jacobs♦
yesterday
add a comment |
TL;DR
The short answer is that you don't. Big, upfront planning is orthogonal to agile development. Instead, you should focus on iterative and incremental development with tight feedback loops to ensure that you're building the right things and embracing change throughout the project's life cycle.
Big, Upfront Requirements an Anti-Pattern
Doing detailed or large-scale requirements at the inception of a project is an agile anti-pattern. In particular, the Manifesto for Agile Software Development values:
Working software over comprehensive documentation[.]
Likewise, Scrum Theory explicitly avoids the use of fixed, upfront planning:
Scrum employs an iterative, incremental approach to optimize predictability and control risk.
While there is nothing stopping you from linking user stories or other types of Product Backlog Items to functional requirements, doing so is often a "project smell" that you're fixing scope, which is ideally the movable part of the Iron Triangle in Scrum. Furthermore, it's often an indication that you're making implementation decisions too early in the process. Lean practices require that you make architectural and design decisions at the last responsible moment, which is almost never at the very beginning of a project when functional requirement specifications are usually gathered.
What to do Instead
Within the Scrum framework, you should be leveraging the framework to perform just-in-time planning at the proper level of granularity. In particular:
- Leverage Backlog Refinement to identify work that will likely be in scope for the next iteration, maximizing the amount of work not done.
- Use Sprint Planning to decompose work into tasks and deliverables only for the current increment, optimizing for just-in-time planning.
- Leave implementation details out of Product Backlog and (most) Sprint Backlog items, allowing for greater flexibility.
- Gather feedback from stakeholders during the Sprint Review to identify changes and refinements to be treated as new work, allowing the project to continually evolve to meet changing market demands and to take advantage of lessons learned.
While not required by Scrum, agile practices generally require integrating test-driven design or behavior-driven development (often in collaboration with stakeholders or customers) to ensure that any functional requirements in scope for the current iteration are well-defined and testable. This type of "living documentation" is often more useful, more accurate, more maintainable, and more effective than typical functional requirements documents.
TL;DR
The short answer is that you don't. Big, upfront planning is orthogonal to agile development. Instead, you should focus on iterative and incremental development with tight feedback loops to ensure that you're building the right things and embracing change throughout the project's life cycle.
Big, Upfront Requirements an Anti-Pattern
Doing detailed or large-scale requirements at the inception of a project is an agile anti-pattern. In particular, the Manifesto for Agile Software Development values:
Working software over comprehensive documentation[.]
Likewise, Scrum Theory explicitly avoids the use of fixed, upfront planning:
Scrum employs an iterative, incremental approach to optimize predictability and control risk.
While there is nothing stopping you from linking user stories or other types of Product Backlog Items to functional requirements, doing so is often a "project smell" that you're fixing scope, which is ideally the movable part of the Iron Triangle in Scrum. Furthermore, it's often an indication that you're making implementation decisions too early in the process. Lean practices require that you make architectural and design decisions at the last responsible moment, which is almost never at the very beginning of a project when functional requirement specifications are usually gathered.
What to do Instead
Within the Scrum framework, you should be leveraging the framework to perform just-in-time planning at the proper level of granularity. In particular:
- Leverage Backlog Refinement to identify work that will likely be in scope for the next iteration, maximizing the amount of work not done.
- Use Sprint Planning to decompose work into tasks and deliverables only for the current increment, optimizing for just-in-time planning.
- Leave implementation details out of Product Backlog and (most) Sprint Backlog items, allowing for greater flexibility.
- Gather feedback from stakeholders during the Sprint Review to identify changes and refinements to be treated as new work, allowing the project to continually evolve to meet changing market demands and to take advantage of lessons learned.
While not required by Scrum, agile practices generally require integrating test-driven design or behavior-driven development (often in collaboration with stakeholders or customers) to ensure that any functional requirements in scope for the current iteration are well-defined and testable. This type of "living documentation" is often more useful, more accurate, more maintainable, and more effective than typical functional requirements documents.
answered 2 days ago
Todd A. Jacobs♦Todd A. Jacobs
34k333121
34k333121
This appears to be only a partial answer. If you don't write a large requirements document, where (and when) do you take note of those pesky details like number of login attempts and required password strength. Those are not implementation details that you can completely leave out.
– Bart van Ingen Schenau
yesterday
@BartvanIngenSchenau "Pesky details" should be driven out empirically. Simple or obvious ones are generally captured in executable tests when a feature comes into scope. Others will be discovered through the inspect-and-adapt cycle, and become refinements captured as new work for future iterations. The whole point of many agile practices is to avoid over-constraining the solution space and encourage emergent design, which is why you should not spec out implementation details until the last responsible moment.
– Todd A. Jacobs♦
yesterday
add a comment |
This appears to be only a partial answer. If you don't write a large requirements document, where (and when) do you take note of those pesky details like number of login attempts and required password strength. Those are not implementation details that you can completely leave out.
– Bart van Ingen Schenau
yesterday
@BartvanIngenSchenau "Pesky details" should be driven out empirically. Simple or obvious ones are generally captured in executable tests when a feature comes into scope. Others will be discovered through the inspect-and-adapt cycle, and become refinements captured as new work for future iterations. The whole point of many agile practices is to avoid over-constraining the solution space and encourage emergent design, which is why you should not spec out implementation details until the last responsible moment.
– Todd A. Jacobs♦
yesterday
This appears to be only a partial answer. If you don't write a large requirements document, where (and when) do you take note of those pesky details like number of login attempts and required password strength. Those are not implementation details that you can completely leave out.
– Bart van Ingen Schenau
yesterday
This appears to be only a partial answer. If you don't write a large requirements document, where (and when) do you take note of those pesky details like number of login attempts and required password strength. Those are not implementation details that you can completely leave out.
– Bart van Ingen Schenau
yesterday
@BartvanIngenSchenau "Pesky details" should be driven out empirically. Simple or obvious ones are generally captured in executable tests when a feature comes into scope. Others will be discovered through the inspect-and-adapt cycle, and become refinements captured as new work for future iterations. The whole point of many agile practices is to avoid over-constraining the solution space and encourage emergent design, which is why you should not spec out implementation details until the last responsible moment.
– Todd A. Jacobs♦
yesterday
@BartvanIngenSchenau "Pesky details" should be driven out empirically. Simple or obvious ones are generally captured in executable tests when a feature comes into scope. Others will be discovered through the inspect-and-adapt cycle, and become refinements captured as new work for future iterations. The whole point of many agile practices is to avoid over-constraining the solution space and encourage emergent design, which is why you should not spec out implementation details until the last responsible moment.
– Todd A. Jacobs♦
yesterday
add a comment |
As said by others, details should be clarified at the last responsible moment, sometimes at the moment of implementation in close collaboration between developers and e.g. business people or UX experts. However, specific information could be noted as acceptance criteria. More general and repeating criteria may be better placed within the team's (or organizations) Definition of 'Done'.
For acceptance criteria you may also want to take a look at a syntax like Gherkin
-- and you may want to automate testing with things like Cucumber as a living, more value-adding documentation and base for regression testing.
New contributor
add a comment |
As said by others, details should be clarified at the last responsible moment, sometimes at the moment of implementation in close collaboration between developers and e.g. business people or UX experts. However, specific information could be noted as acceptance criteria. More general and repeating criteria may be better placed within the team's (or organizations) Definition of 'Done'.
For acceptance criteria you may also want to take a look at a syntax like Gherkin
-- and you may want to automate testing with things like Cucumber as a living, more value-adding documentation and base for regression testing.
New contributor
add a comment |
As said by others, details should be clarified at the last responsible moment, sometimes at the moment of implementation in close collaboration between developers and e.g. business people or UX experts. However, specific information could be noted as acceptance criteria. More general and repeating criteria may be better placed within the team's (or organizations) Definition of 'Done'.
For acceptance criteria you may also want to take a look at a syntax like Gherkin
-- and you may want to automate testing with things like Cucumber as a living, more value-adding documentation and base for regression testing.
New contributor
As said by others, details should be clarified at the last responsible moment, sometimes at the moment of implementation in close collaboration between developers and e.g. business people or UX experts. However, specific information could be noted as acceptance criteria. More general and repeating criteria may be better placed within the team's (or organizations) Definition of 'Done'.
For acceptance criteria you may also want to take a look at a syntax like Gherkin
-- and you may want to automate testing with things like Cucumber as a living, more value-adding documentation and base for regression testing.
New contributor
New contributor
answered 10 hours ago
Thorben EgbertsThorben Egberts
12
12
New contributor
New contributor
add a comment |
add a comment |
I think part of the problem is that this:
login with my username and password
is not a requirement. It's a design choice masquerading as a requirement. The real requirement is something like: "As a user I need to (securely and uniquely) authenticate with the system so that I can ..." Choosing username and password immediately rules out other, lower friction, means of authentication. Already logged in to Active Directory/G Suite/Office 365/another Oauth provider? Can we use that? What about facial recognition and fingerprint? Is that sufficient?
Keep this in mind as you go through your user stories. Are they telling you how something should be done instead of what needs to be done? Quite often this is OK; they're expanding on/clarifying earlier design choices. But sometimes it's worth taking a step back, asking yourself what problem are they really solving, and is there a better way?
New contributor
add a comment |
I think part of the problem is that this:
login with my username and password
is not a requirement. It's a design choice masquerading as a requirement. The real requirement is something like: "As a user I need to (securely and uniquely) authenticate with the system so that I can ..." Choosing username and password immediately rules out other, lower friction, means of authentication. Already logged in to Active Directory/G Suite/Office 365/another Oauth provider? Can we use that? What about facial recognition and fingerprint? Is that sufficient?
Keep this in mind as you go through your user stories. Are they telling you how something should be done instead of what needs to be done? Quite often this is OK; they're expanding on/clarifying earlier design choices. But sometimes it's worth taking a step back, asking yourself what problem are they really solving, and is there a better way?
New contributor
add a comment |
I think part of the problem is that this:
login with my username and password
is not a requirement. It's a design choice masquerading as a requirement. The real requirement is something like: "As a user I need to (securely and uniquely) authenticate with the system so that I can ..." Choosing username and password immediately rules out other, lower friction, means of authentication. Already logged in to Active Directory/G Suite/Office 365/another Oauth provider? Can we use that? What about facial recognition and fingerprint? Is that sufficient?
Keep this in mind as you go through your user stories. Are they telling you how something should be done instead of what needs to be done? Quite often this is OK; they're expanding on/clarifying earlier design choices. But sometimes it's worth taking a step back, asking yourself what problem are they really solving, and is there a better way?
New contributor
I think part of the problem is that this:
login with my username and password
is not a requirement. It's a design choice masquerading as a requirement. The real requirement is something like: "As a user I need to (securely and uniquely) authenticate with the system so that I can ..." Choosing username and password immediately rules out other, lower friction, means of authentication. Already logged in to Active Directory/G Suite/Office 365/another Oauth provider? Can we use that? What about facial recognition and fingerprint? Is that sufficient?
Keep this in mind as you go through your user stories. Are they telling you how something should be done instead of what needs to be done? Quite often this is OK; they're expanding on/clarifying earlier design choices. But sometimes it's worth taking a step back, asking yourself what problem are they really solving, and is there a better way?
New contributor
New contributor
answered 2 hours ago
pgspgs
1012
1012
New contributor
New contributor
add a comment |
add a comment |
Achilles is a new contributor. Be nice, and check out our Code of Conduct.
Achilles is a new contributor. Be nice, and check out our Code of Conduct.
Achilles is a new contributor. Be nice, and check out our Code of Conduct.
Achilles is a new contributor. Be nice, and check out our Code of Conduct.
Thanks for contributing an answer to Project Management Stack Exchange!
- Please be sure to answer the question. Provide details and share your research!
But avoid …
- Asking for help, clarification, or responding to other answers.
- Making statements based on opinion; back them up with references or personal experience.
To learn more, see our tips on writing great answers.
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function ()
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fpm.stackexchange.com%2fquestions%2f26166%2fhow-to-refer-to-functional-requirement-specifications-frs-from-user-stories%23new-answer', 'question_page');
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function ()
StackExchange.helpers.onClickDraftSave('#login-link');
);
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
-agile, documentation, scrum, user-stories
1
On a side note, having "hundreds or thousands of tiny stories" is generally an anti-pattern in itself. Most of what you're envisioning as stories are better captured in tests, the Definition of Done, or items on the Sprint Backlog (if they have to be captured at all). User story development is an art, not a science, so please browse the user-stories tag or read Mike Cohn's books on the subject for more thorough guidance on how to find the right balance of granularity for your project.
– Todd A. Jacobs♦
yesterday