I will be using TFS 2012 and I am confused as to how to setup work items for one job where there are dependencies to the steps needed to get the job completed. For example, if the job first needs to get feedback from the end user, then a developer needs to build the base classes. After the base class work is completed then another developer needs to build the UI components. After the UI is completed then the tester needs to test the work. This job requires multiple people, including more than one developer. Each step cannot be started until the prior step is done. Should all of these steps be different work items or all in one work item? If multiple work items, how do you have the work item show as ready to work on for the next person when the prior work item is completed? If only one work item, then how do you handle the steps for multiple developers? This is one example. There could be the case where we have five developers all dependent upon each other before they can start their own work.
It sounds like you're trying to fit TFS into a formal waterfall process. It probably isn't going to be a good fit in terms of creating Gantt charts for you. In TFS you can use the hierarchy of user stories and tasks to accomplish half of what you want. For the other half you can create the appropriate link type between the tasks.
However, TFS isn't going to give you a Gantt chart like view for them, it isn't designed that way. If you really want to manage projects in this fashion, I'd look at integrating TFS with MS Project and/or Project Server.
As an aside, I would strongly consider just having those people talk to each other rather than relying on a tool.
As long as your performing an agile process your on the right track. Sprints should be based on PBI deployment, not completed tasks. If you find yourself pushing a PBI across multiple sprints, you may want to break-up your PBI. It is better to do this than keep wondering if your team is getting things done, since a group of tasks are moving into a new sprint. Getting a PBI to completed at the end of a sprint should be a key goal for an agile team.
Assign all the tasks needed to complete the PBI. Tasks should be created by the team together. This will help decide how to break down the tasks. I would break down the tasks mentioned into independent tasks based on functional groupings (UI, Business Model, ect). The art of this is to not break them down too much. The team will decide this for themselves. (remember to keep agile and let the team make short-term mistakes if it will help long-term: estimation, scope, quality, ect.
Assign QA tasks with unique names for each PBI. Don't use QA for the task name, it can become difficult to prioritize on the Board view. If you have a test team, let them create there qa tasks. Agile is agile (the team is the team).
The other main key point I learned was don't move on to tasks until the PBI has been planned completely, don't move on to sprinting until the tasks have been planned completely. This will help ensure that once your are sprinting, your not making decisions for that sprint in the middle of the sprint.
I hope this gives you some pointers.
Related
My team is asking me to add all these states in the PBI workflow.
New,
Prioritization,
Design,
Business Review,
IT Review,
Approved,
Committed,
In Development,
Development Done,
QA Testing,
Ready for UAT,
Released to UAT,
UAT Testing,
Available in UAT,
Ready for Production,
Released,
Reopen,
Resolved.
I know that we can accomplish the same by using Tasks or Reason field and we have to keep the workflow "Simple" but my team is insisting to track that using a single field (State) so that it is clear. I would like to know if it is a good idea.
I appreciate your thoughts and feedback.
We can't say how many states are reasonable or best. TFS is extensible and customizable, it is designed for customers will be able to meet the needs of the organization.
But as we know, the more states you define, the more transitions you must define. The maintenance and further upgrades will be more complex. Changing the workflow states of work items, specifically those in the task and requirement category can cause unexpected challenges in existing functionality as well as future upgrades. Changing to requirement types (Product Backlog Items and Bugs for Scrum, User Stories for Agile and Requirements for CMMI) will require modification of the Agile or Kanban board. They will also most certainly prevent an automatic easy template upgrade.
Customization should be well-thought out, instead of changing the existing State field, you may consider add a new "customStatus" field which won't impact existing reports and upgrades.
A good blog for your reference: http://blog.nwcadence.com/tfs-customization-pitfalls-payoffs/
This is another option for you to think about but you don't necessarily need to amend the states. You could use Board Columns which can be set on the Kanban board. With each column, you can optionally choose to split containing a Doing and a Done which could mean you require less states.
You can then query on Board Column instead of State
I was in a similar scenario to you when setting up our TFS (although not with as many states requested!) and I ended up going with Board Columns. Here is ours, it seems to work for us:
All of these have no split with the exception of In Development because when development is done it is not necessarily ready for test.
This functionality came with TFS 2015 Update 1 so you would need to upgrade if you're not on that version.
Here is how we use each state:
New - New PBI or Bug
Approved - Confirmed the work will be done and complies with the DOR (Definition of Ready)... (Contains enough info, priority assigned, tasks created, test plan created etc)
Committed - Assigned to a future sprint
In Development - Contains a Doing and a Done
In Test - QA
Ready for Release - Signed off and ready for release
Done - Released and DOD (Definition of Done) has been completed.
We're still fine-tuning our ALM process using TFS 2015 Update 1 On-Prem. We are using the standard SCRUM template and we display bugs on the backlog, along with requirements. Bugs are reported by the business and go through the same level of analysis as PBIs in that they will contain child tasks:
Now for PBIs, when a tester is testing the PBI and discovers a bug with it (which needs to be fixed as part of this sprint), they will create a bug as a child to the PBI. This keeps them together on the task board. 1 PBI may have many bugs and these may be worked on by different people. These child bugs will have child tasks.
The process mostly works but on the Kanban board, the child bugs are shown, the parent PBIs are not. Why not? and how can I work-around this? I can link them differently but we want them to stay together on the boards.
Thanks
It feels like you're really mixing and matching the two supported scenarios here.
Personally I prefer not to create Bugs as part of the sprint (to me they're not really bugs if they haven't made it out of the iteration) and often it's used as a communication mechanism instead of dev & test working closely together.
If you want something on the board under the PBI/Bug, you could use a Task Work Item (or a custom type) and then use the funky card colouring on the board to look for a tag to signify that it's an in-sprint bug/issue.
Highlight work items based on custom criteria
My team recently switched to using Team Foundation Server to support Agile. We decided to run sprints every two weeks. We plan to write the stories so, ideally, they can be finished at the end of each two week sprint. We find that some stories have tasks (usually research or learning someone elses API) that will take much longer than our sprint duration. Does TFS have some way to record effort into such tasks without making it look like the stories should be completed at the end of the current sprint? Failing TFS, is there some 'Agile' way of handling these items?
I suggest you figure out how to break down the work into smaller pieces. My rule of thumb is a Task should be more than an hour and less than a day.
Alternatively, you can still create Tasks against User Stories that aren't assigned to a Sprint if you choose to. Although that doesn't feel very Agile to me.
I have been using Rally for Project Management in my previous organization, and now I have to use Jira Agile for the same job in the new organization. I am having hard time understanding the way JIRA Agile works, and could not get a hang of the tool after a week of struggle. I am sorting expert help for what I would like to achieve. I have been using JIRA for many years as a bug logging tool but not as project management software.
All I want is to create an Epics and Stories, schedule it into a particular release or sprint. On Rally this is straight forward. Few images attached here.
I could also see the burn-down once I do the above setup, and the developers/qa start burning down or burning up the hours.
I could not achieve the same on JIRA. It asks me to create a scrum board, but I don't have a clue on how to add the child tasks to a story without creating a new child task (which I don't prefer as the tasks were already created and few started progressing).
The scrum board is also not the way it is on Rally, as it does not list the stories but directly shows the tasks which I am unable to correlate with the story. Can any one point me to a proper tutorial or assist me based on your experience in JIRA? Thank you in advance.
I can recommend two things that might make it a bit more easier for you to transition from how you structured your projects before: the Jira plugin "Structure" and using epics, stories and sub-tasks in a defined and controlled manner.
About the plugin: Structure allows you to define a structure, a container that may even span multiple projects, and lets you put issues in. Secondly, and more important, it allows to create any number of sub-task levels. You can use the structure view to show and hide sub-levels, or if you use the agile boards you can just apply a quick filter to the board.
The same goes for using epics, stories and sub-tasks, just make sure everyone able to enter issues follows the same criteria and then add some filters.
Hope this helps a bit
You may want to look at https://confluence.atlassian.com/display/AGILE/JIRA+Agile+101 - it should cover most of the basics to get you going.
In the default TFS setup there are three work item types: scenario, task and bug. That last one is quite straightforward, and task also: it's a specific job for a team member to complete. But I think scenario is a bit vague.
I usually create a scenario for larger and more general units of work: for example "Create functionality to add employee lines to an employer." Smaller, more specific work items would then be tasks, for example: "Create detail form.", "Create save method on server.", etc
When I check in changes I link the changeset to the scenario AND to the specific task. Is this a good habit? How do you deal with tasks and scenarios? Any resources to best practices?
I've also heard scenarios are actually meant for use cases, is this so?
Scenarios can be any user story.
You only need to check in to the task.
When tasks are created, they should be linked to a Scenario first, before assigned to developers.
That way the association between checkins and scenario is automatic (and reportable).
No point double handling
In the MSF Agile template, Scenarios can also be thought of as "User Story" - kinda like a lightweight agile use case.
The Scenario details the broad picture of the functionality that is wanted to be implemented, recording a single path of a users interaction with a part of the system. For example, in Stack Overflow a couple of Scenarios might be "Ask a Question" or "Answer a Question". Scenarios and Quality of Service Requirements can be thought of as top level work items in MSF Agile (i.e. the work items that define the system) with Scenarios being functional requirements and Quality of Service being non-functional requirements.
I tend to create multiple tasks from each scenario and typically only record my check-ins against the task. In TFS 2010 properly hierarchical work items are coming which will make this way of working easier to report on. Currently work item associations are bi-directional (i.e. you can say that a task is associated with a scenario but you cannot say that it is a child of it).
There is nothing wrong with marking your check-in against the task and scenario, just that it creates more work for you when checking in. Also, the scenario might be getting delivered by a number of developers were-as a task tends to be down at the granularity of individual person activities.
If you are doing a lot of associating of a work item to a scenario, then the following tip might be handy for you (http://www.woodwardweb.com/vsts/top_tfs_tip_3_r.html). It shows you how to modify the standard MSF Agile process template to remove the ability for check-in's to resolve the Scenario but just associate the check-in with that work item. Resolving on check-in for a long running work item like a Scenario is nearly always not what you want to happen - but is the default behavior out of the box.
Hope that helps.
If by "default TFS setup" you mean the "MSF for Agile Software Development" project template, then a scenario is defined as follows:
A scenario is a type of work item,
recording a single path of user
interaction through the system. As the
persona attempts to reach a goal, the
scenario records the specific steps
that they will take in attempting to
reach that goal. Some scenarios will
record a successful path; others will
record an unsuccessful one. When
writing scenarios, be specific as
there are many possible paths.
To get a bit more info on this, have a good look at the "Documents/Process Guidance" folder under the project in team explorer - it explains the recommended process fairly well
You can think of scenarios as representing the users perspective, whereas tasks are the developers perspective. According to the MSF Agile documentation a scenario "represents a single path of user interaction through the system you are building.", and a task "identifies a specific item of work for a team member to perform."
Tasks can be linked to scenarios. When checking in you, as a developer, have solved a task, not the scenario, so you should relate the changeset to this task.