NOTE: This post originally appeared on my former BoosianSpace blog on 2 Nov 2011.
I have a colleague here at EPA, she was very interested in getting started using an Agile approach to help her produce a better project (or really the software application they were to build). I’m going to repeat and expand our conversation in the hope that it may prove useful for others. This is set of recommendations I had for her based on her context. I’ll start with a brief overview of that context.
This will be a greenfield development project; i.e. there is no legacy code to worry about or legacy data to migrate. It is intended to be a public facing web application. The infrastructure is fairly open, but will need to incoporate GIS services that deal with watersheds; if she finds it useful she may utilize a cloud service to host this. As a public site, it needs to comply with Section 508. There is some consideration for a mobile app as well…
The development work will be done by an offsite contractor; this contractor to her knowledge has not done any Agile development projects as of yet. The GIS services portion will most likely be developed by a specific subcontractor on that team and another may provide UX. Her biggest constraint will most likely be available funds; schedule and scope (hopefully) can both be in play.
Finally, she has a very interested Govt product owner and a group that is interested in participating that represents stakeholders of urban watersheds. The target goal is to have people represent the interests and activities occurring at particular local, small watersheds and then utilize GIS services to identify the larger watersheds these are a part of so the relevant groups of interest (e.g. Chesapeake Bay Foundation) can be portfolio managers of these watersheds and provide upper level guidance.
She was interested in getting started. I had previousl recommended some books/directions for learning and I’ll repeat some of those here as they apply. But she was interested in some specifics.
My first recommendation was to develop a project charter; this should have the following:
- A description of the project goals and risks
- A relevant ranking of these goals from a simply worded measurement perspective; I recommended having 4-6 of these in the Project Success Sliders format. This allows people to understand that trade-offs must be made. How she gets there should be a facilitated project charter discussion.
- If needed, a description of roles and responsibilities of the organizations contributing to/participating on the project. I’m not sure this is necessary given she has an engaged stakeholder.
Finally, I’d suggest that the project charter have a high level prioritized set of functional areas/epics as a roadmap for what will be developed (essentially it shoudl include a release plan). If she is able, she can get a high level of estimates in time for these with the potential contractor, add some management reserve and then calculate the amount of funds to develop and a maintenance estimate for this with a presumed product life-cycle of 5 years. The roadmap should have the highest business value and riskiest items first, then simply high business value, then simply risky, and lastly other items that are desired. This will ensure that risky items have less opportunity to hold-up the project in its delivery of high business value items.Once funded, the roadmap will have only a subset of activities that can be met, this will become the release plan.
I’d recommend doing this as time and materials with an award fee. The bid should be in two parts: the initial development to release 1.0 and the long-term software maintenance of the resulting application as an option. This perhaps could be a fixed yearly cost. I recommended a warranty period (perhaps 60 days) to assess how well the application is doing from a quality standpoint. Depending on how good (or bad) the application turns out to be, you can execute this option. Really good, execute it if it is a good deal. It also could potentially give you a point for renegotiating. If it is really bad, the team that developed is probably the best team to maintain it also, but there would need to be some incentives around improvement.
I recommended that the contract call for a dedicated team and that team’s full participation along the entire development project AND the optional maintenance component if executed.
I’d make the award two-fold, the execution of the maintenance option is one. The bigger one though is that if the contractor delivers under budget (the contract ceiling on development) and the quality is an acceptable level; then the remainder of the funds get split in half – the contractor gets that as pure profit, the agency can deobligate the other half and use it for something else. It’s a win-win.
These above recommendations need to be worked out with the Contracts Office.
Recommended Agile Approach
I recommended starting with Scrum as an Agile Project Management framework. I made this recommendation based on a few things:
- It is lightweight and supports rolling wave planning so that detailed tasks can be articulated just-in-time
- It looks as though there will be an engaged product owner and a set of actual users that can be tapped to provide rapid feedback
- Given her and the product owner will get a set amount of funding, which will then layout what prioritized epics that can be accomplished, she will need to be able to measure progress; Scrum’s velocity technique is useful for this. As an initial start, I recommended 2 week Sprints and if the team finds they aren’t making what they pull in consistently regardless of how many that are pulled in, perhaps shorten the iteration time to one week.
- Given the stakeholder audience and non-familiarity with techniques such as planning poker, I recommended the concept of inch-pebbles, all tasks/stories should be broken down in Sprint Planning to something that will last no longer than 2 normal workdays or less as a work estimate.
- The initial Sprint planning session should be expected to be about 4 hours. All remaining ones could be planned to be 2 hours. The Sprint Plan should be the prioritized backlog of stories/tasks and also identify when subject matter expertise is needed. This will allow an estimate of when these people need to be available to provide information as requirements.
- Sprint Reviews should be scheduled for about 2 hours and consist of a demo of ‘done’ software; the definition of ‘done’ should be very clear and agreed upon by all parties. I’d recommend ensuring it is deployable ready software. It’s been coded, tested, added to the build, and had some amount of regression testing done. Again because of lack of expertise, I’m not counting on any continuous integration or automated test suite to be activated. Regression testing will be smoke tests in reality.
- Retrospectives should be scheduled for about 2 hours and directly follow Sprint Review. This needs to be sold to the product owner as how the team can improve AND possibly deliver more or deliver what can be done at lower cost while still maintaining quality. It won’t guarantee it, but it will improve the chance it will happen. I recommend conducting the Retrospectives using the format described in Esther Derby and Diana Larsen’s book Agile Retrospectives.
- Try and make the Retro immediately follow the Review and the next Planning session immediately follw the Retro.
- Plan for a daily stand-up of 15 mnutes max. Investigate some form of teleconference/vid conference capability for this. Do the same with some on-line white-boarding, mind-mapping, etc. for the Sprint Planning/Review and Retros. The team will be distributed. If possible, try and bring as much of the team together as possible for the Review/Retro/planning sessions.
Recommended Technical Practices
I’ll conclude with a set of technical practices I recommended. Due to the team’s lack of experience,I didn’t recommend too many; I tried to focus on a few key items that ensure the team delivers high quality software and that what ever is delivered meets the requirements specified. The entire scope may not be completed, but you want it working correctly and properly.
Good SOLID principles will be the foundation.
Use of Specifications by Example (see book of the same title by Godjko Adzic), whether automated with Cucumber, Lettuce, Fitnesse, or JBehave or performed manually will ensure the software meets requirements. It makes it easy to iterate over the requirements as well.
Develop for a scenario at a time. Use unit testing and develop tests before coding. Once a test has been written, check into the source code repository. Once the code has been written and passes the test, check it into the source code repository. Iterate until the scenario test passes. Move onto the next scenario. Once all scenarios have passed, move to the next requirement/example set.
At least every 2-3 days have someone execute elected sets of the specs fully for the entire app to date to see if any bugs have crept in as new features get implemented.
Use an issue tracker for the tasks/stories and also to track any bugs that show up during regression tests; I recommend Trac. It’s OSS and works well. It allows implementation of a pull process so that as developers bring stories into work from the backlog and they immediately get assigned as owners. This is useful for the PM (Scrum Master) to see what is being worked at any point in time.
I hope folks find this useful for how to ease into being Agile if they have a similar context. There is no one size fits all approach though, so consider this as just one approach. because there is a clear product owner, interested user representation, and it is a greenfield project, this was my set of recommendations to try initially. Using Retrospectives, hopefuly the team will adapt what I described above to meet their needs.