Setting Up Project 2010 for Agile Development

When teams start going down the path of agile development, often one of the first things they’ll do is throw away the project plan. This is almost never a good idea as the project plan can be a guide to help with capacity planning, release planning, and managing the project resources who are assigned to tasks.  MS Project diagrams can also be an excellent communication tool if built with communication in mind.  In the spirit of Agile development, we want to eliminate all activities that do not directly contribute to the team delivering a working product.  This means working with a project plan that can contribute to sprint planning and the achievement of release cycles.

Many developers and team leads have built a strong hatred for Microsoft Project as improper setup and unfamiliarity with the tool can lead to frustration as Project tries to adjust values and balance tasks across the team.  This posting builds on my previous post on Work vs. Duration for development teams helping you to set Project 2010 up to correctly from the beginning to make working with your project plan a much better experience. 

  Project 2010 Settings

 

All of the following settings can be accessed within the project options.   Click on the File tab, Select Options, then select Schedule from the pane on the left.

Hour per Day — It is generally accepted that you are only going to be getting about 6.5 hours of actual development from the developers on your project as the remainder of the time will be spent in meetings, research, collaboration and other activities that, while they do contribute to the project, do not contribute to the burn down.  Because you are entering your tasks in units of work, this will allow MS Project to plan for this overhead as it levels resources across the tasks.  This takes a bunch of the confusion out of the project plan and help MS Project to give you a reasonable result should you put more than one person on a given task, building in some overhead for the collaboration. 

You might be wondering what to do in a situation where not all resources will be working like this — Project Managers, Business Analysts, System Configuration guys and the like.  If you are mixing both types of roles on one project plan, you have to get a little bit fancy, but it is not too bad.   In this case, you would need to build separate calendars for development and time-based people.  Then on the resource management screen, you get to choose which calendar you would like each person to follow.  Perhaps this would be a good topic for a future posting…

Hours per Week — This is an extension of the Hours per Day above and the two should always be adjusted in tandem to match.

New Tasks Created — This should be set to Auto Scheduled.  Project 2010 lets you designate which line items on the plan should be leveled.  In practice, you should let most things be handled by the resource leveling function and focus on the dependencies for order.  I find it is easier to just let project do this from the beginning.  This also allows you to see the task relationships right away as the linking makes it much clearer than all those lines that you have to chase like some kind of maze.

Duration is Entered in — This should almost always be set to Days.  This your barometer of how long a task will take to get accomplished with the currently-assigned resources.  For tasks that are effort-driven (development) these should be calculated units rather than something entered. 

Work is Entered in — This should always be set to Hours.  This is the units that the development estimates are recorded in. 

Default Task Type — This should be set to Fixed Work.  This means that the default task will be entered in units of Work rather than time.   This is true for most development projects.  You’ll notice that this automatically sets the check-box for “New tasks are effort driven“.

In practice, this means that you will need to think about the work that is being done and come to a conclusion as to whether it is effort-based or time-based.  With this setting, you will need to go into the properties of the time-based work items and uncheck the “Effort Based” property.  If you think you are going to have a lot of these types of work items, you might choose to add the Effort Based column to the GANTT view so you can do this quickly.

You might be asking yourself what happened to Story Points?!  What’s all this talk of hours?  Microsoft Project is a planning and sourcing tool and should be used at the point where you are planning out the actual work to be executed.  As you go into your sprint planning cycle to initiate the next sprint, there are two ways you can approach this.  From a capacity perspective, you might take the look at the historical relationship between Story Points delivered and Sprint Capacity to put this in at the Story-level.  The other option is to do this as a sprint-based work breakdown structure as you decompose your stories into individual tasks and take the summation of the individual estimates.  Both are valid approaches, but are dependent upon your discipline and the depth of your sprint planning cycle.  I prefer the latter approach, but I understand that project constraints sometimes don’t allow for that level of decomposition.

 

Project 2010 Settings for Agile and Scrum Projects
Project 2010 Settings for Agile and Scrum Projects
Advertisements

MS Project Integration with Scrum for Team System 3.0 (SFTS)

When using the Scrum for Team System 3.0 template from EMC (formerly Conchango) the integration with Microsoft Project doesn’t recognize the ImplementedBy link that is used to create the Parent/ Child relationships between the Product Backlog Items (PBIs) and the Sprint Backlog Tasks (SBTs). 

To make this work, you simply have to update the FileMapping.Xml file that is in the Classification directory.  If you need to update a project that is already deployed, however, you’ll need to import the new file with the TfsFieldMapping command on the server.

To update the file, simply add the HierarchyLinkType key.   I have included the entire file for SFTS below.

<?xml version="1.0" encoding="utf-8"?>
<MSProject>
  <Mappings>
    <Mapping WorkItemTrackingFieldReferenceName="System.Id" ProjectField="pjTaskText10" ProjectName="PB Item ID" />
    <Mapping WorkItemTrackingFieldReferenceName="System.Title" ProjectField="pjTaskName" />
    <Mapping WorkItemTrackingFieldReferenceName="System.WorkItemType" ProjectField="pjTaskText2" />
    <Mapping WorkItemTrackingFieldReferenceName="System.AreaPath" ProjectField="pjTaskOutlineCode9" />
    <Mapping WorkItemTrackingFieldReferenceName="System.State" ProjectField="pjTaskText3" ProjectName="PB Status" />
    <Mapping WorkItemTrackingFieldReferenceName="System.IterationPath" ProjectField="pjTaskOutlineCode10" />
    <Mapping WorkItemTrackingFieldReferenceName="System.Rev" ProjectField="pjTaskText23" />
    <Mapping WorkItemTrackingFieldReferenceName="System.AssignedTo" ProjectField="pjTaskResourceNames" />
    <Mapping WorkItemTrackingFieldReferenceName="Scrum.v3.WorkRemaining" ProjectField="pjTaskRemainingWork" ProjectUnits="pjHour" />
    <Mapping WorkItemTrackingFieldReferenceName="Scrum.v3.EstimatedEffort" ProjectField="pjTaskWork" ProjectUnits="pjHour"/>
    <Mapping WorkItemTrackingFieldReferenceName="Scrum.v3.TaskPriority" ProjectField="pjTaskText12" ProjectName="Task Priority" />
    <Mapping WorkItemTrackingFieldReferenceName="Scrum.v3.BusinessValue" ProjectField="pjTaskText13" ProjectName="Business Priority" />
    <LinksField ProjectField="pjTaskText26" />
    <SyncField ProjectField="pjTaskText25" />
    <HierarchyLinkType LinkType="Scrum.ImplementedBy" />
  </Mappings>
</MSProject>

TFS Custom Links in MS Project 2010

As a project manager, one of the most powerful features of Team Foundation Server 2010 is the ability to create links between work items. While there are several different kinds of links that are built into TFS by default, you’ll often want to create custom link types to streamline your reporting as well as the interface within VSTS.

As a project manager, one of the most powerful features of Team Foundation Server 2010 is the ability to create links between work items.  While there are several different kinds of links that are built into TFS by default, you’ll often want to create custom link types to streamline your reporting as well as the interface within VSTS. 

MS Project integrates tightly with TFS and recognises two different kinds of relationships when you are importing work items from the system.

Hierarchy — This is the tree-based relationship that allows work items to roll up into each other.  In MS project, this is represented by summary tasks with all of the children under it.  By default, TFS uses System.LinkTypes.Hierarchy for this relationship.

Dependency — These are the relationships between work items that sets the order that they need to be accomplished in the plan.  This means that the ordering and resource leveling will follow this map.  By default, TFS uses System.LinkTypes.Dependency for this relationship.

If you need to remap these to your custom LinkTypes, it is a simple change to the FileMapping.XML file in the Template’s Classification Directory.  You simply need to add the following keys to the Mappings in the XML, specifying the names of the LinkTypes you’ve created.

HierarchyLinkType
<HierarchyLinkType LinkType=”MyNamespace.LinkTypes.MyHierarchyLinkType” />

DependencyLinkType
<DependencyLinkType LinkType=”MyNamespace.LinkTypes.MyDependencyLinkType” />

Note that the documentation on MSDN has incorrect syntax and will throw an exception when you try to export to MS Project.

Using MS Project 2010 for Software Development Projects – Work vs. Duration

There is a general misconception that Microsoft Project, or many of the commercially-available project management applications, doesn’t work well for software development projects. When talking with Project Managers and Architects, their trouble usually arises from scheduling and resource leveling. They’ve usually been burned by situations where countless hours have been invested into building out a project plan only to find that a minor change skews the plan into an almost unusable mess. There might be many things going on at the same time, but it usually boils down to an understanding of the difference between Duration and Work.

There is a general misconception that Microsoft Project, or many of the commercially-available project management applications, doesn’t work well for software development projects. When talking with Project Managers and Architects, their trouble usually arises from scheduling and resource leveling. They’ve usually been burned by situations where countless hours have been invested into building out a project plan only to find that a minor change skews the plan into an almost unusable mess. There might be many things going on at the same time, but it usually boils down to an understanding of the difference between Duration and Work.

Conceptually, this isn’t a hard distinction. Most people can tell you that Duration is the calendar time it takes to get a task done whereas Work is the number of development hours it takes to complete a given objective. However, in the middle of a project, the distinction is easy to miss especially when the business objectives and the actual project work-stream are expressed in different terms. The business stakeholders want to know when functionality will have to be handed off to other groups for activities like integration testing, security audit, and user acceptance testing – ultimately, when will the functionality be delivered. On the other hand, the development team is used to thinking in development hours and estimated work remaining. All of this is made more complex by the fact that MS Project’s default view is expressed in Duration.

Let’s look at a simple example based on the following Work Breakdown Structure (Not complete, just an example):

WBS Item

Initial Estimate
(Baseline)

Actual Hours

Work
Remaining

Traceability

1.0 – Users can log into the web site (Authorization) and are granted access according to their assigned authorizations 80 Hours 0 hours 80 Hours Use Case 1.0
     1.1 – Develop custom logon control for the upper-right in the Master Page header 20 hours 0 hours 20 hours Use Case 1.0
     1.2 – UX Design for logon flows 8 Hours 0 hours 8 Hours Use Case 1.0
     1.3 – Forgot Password Functionality 20 hours 0 hours 20 hours Use Case 1.0
Alternate Flow (Forgot Password)
          1.3.1 – Forgot Password Challenge Question 12 Hours 0 hours 12 Hours
          1.3.2 – Forgot User Name e-mail process 8 hours 0 hours 8 hours
Other tasks…  

 

I’ve put in a little bit more information into this WBS to prove a point. As you go through your initial planning (at the user story/ product backlog/ use case level) you will be looking at a time-based measurement. Likewise, when you are handing that work into the development queue, the estimates that you will arrive at in your sprint plan will be based on effort. Don’t work if you are using story points at the highest level. These eventually get translated into hours, and should be considered a substitution for the effort measurement.

Pasting this into MS Project 2010, it is tempting to just use the standard Gantt chart, but that leads you directly into the wrong path.

Notice that the column on the default view is Duration – that is, calendar time that is required to get the task done. This works if there is only one person (or resource) working at a time, but this quickly breaks down when you have a team or several teams working on the project at once. Instead, you need to add the Work column to the Gantt chart.

  1. Scroll the tabular view to the right until you can see the ‘Add New Column’ heading
  2. Click on the menu arrow to see the list of available fields
  3. Select the Work Field

Once the actual work is entered for the individual work packages, all items will automatically be marked as Effort Driven and the project plan can be leveled against the resources. Here I have added myself as the resource and have allowed MS Project to rebuild the schedule.

The Final Project Plan

Allocating an additional resource to some tasks in the project (John Gault, in this case) keeps the development effort the same, but MS Project 2010 shortens the overall duration of the project to take advantage of the additional work capacity. With the additional resource, we’ve shaved 2 days of duration off of the project.

Just be sure that when you add additional resources, you tell MS Project how this should affect the task.

Conclusion

With a little planning and attention to work estimates rather than only duration, MS Project can be a huge asset to the software development team. This work/effort-based tracking is vital to effective sprint planning and allows the project team to quickly visualize the workstream against the sprint capacity. This also helps to focus the team on critical path issues that might be missed in a taskboard exercise.