PMI-ACP Learning is Fun

This week I debuted my PMI-ACP class to the Washington DC/Baltimore area. Because this was my first time offering the class, I had a little trepidation. Would my students take to my teaching methods?

As I walked into the training center, I passed another classroom. It was a five-day PMP exam boot camp. Knowing how these types of classes are presented, I knew I didn't want the same for my class.

I want to do more than teach people how to pass a test. I want them to walk away with an understanding of concepts like self-organization, adaptive planning, continuous improvement, and value delivery. For this first class, I planned to spend a lot less time lecturing and a lot more time engaging my students with discussions, simulations, and games.

Over the course of the next three days, we held lengthy discussions on real-world topics. I would introduce a concept and ask questions like, "Now that I've talked about Concept A, how can you apply it at your organization?" The class would then compare and contrast different scenarios from each of their perspectives. But, I have to admit, some of the best moments of the class came when we played games. Activities ranged from building paper airplanes, to playing the "ball point" game and building a town out of Legos. I can't express the satisfaction I felt while witnessing each student's "lightbulb" moment.

One of the attendees just wrote me an email, saying,

The class was excellent! This has been the most valuable class I have had relative to understanding Agile and applying it to my organization.

We had six early-adopters at the first class, all of whom offered up some excellent feedback. I know the next class will be even better. Anyone have some Legos for sale?

5 Steps to Make Your Project Portfolio Flow

In most organizations adopting Agile methods, the techniques used for program and portfolio management are still predictive and "waterfall": yearly budgeting cycles, capacity planning, and heavily matrixed resource management. It’s no surprise then that despite adopting Agile methods for their projects, many organizations have yet to exploit their full benefits at the portfolio level.

Put another way, Agile projects are constrained because their portfolios are clogged with the debris of failing projects, with slow moving projects that delay more critical initiatives, and with the inability to properly staff projects to get them moving at a rate that their business customers would appreciate. How can the project portfolio be fixed so that business value can flow and projects can be completed faster?

Program and portfolio managers have the charter to apply systematic management techniques to collections of projects and deliver business value in line with organizational strategy. In my previous posts on the subject, I laid out principles and practices for a Lean-Agile PMO that use lean principles to accelerate Agile project delivery.

To help you get started, here are 5 steps that you can use to make your project portfolio flow:

1. Terminate Sick Projects. In every organization, there are sick projects. These are projects that fail to deliver value: missing deadlines, not meeting business expectations, and undergoing long and painful “illnesses.” It is reasonable to assume that the majority of investment sunk into sick projects ends up wasted—returning very little value to the business. Consider the time spent by team members on those projects. If the portfolio was purged before these projects, and the project inventory thereby reduced, the team members' effort could be redirected to more productive projects that in turn would finish faster. To begin clearing the debris in your portfolio, don’t avoid the challenge—terminate sick projects as soon as you can.

2. Break Large Projects in Smaller Projects/Increments. In Agile parlance, a minimum marketable feature (MMF) represents a component of intrinsic marketable value. By categorizing and aggregating product features into MMFs, you can recognize and exploit the fact that sets of product features can have value to end users, even if the product is incomplete. Instead of carrying massive project inventory to deliver product functionality in one big bang, deliver products in increments of MMFs and improve lead time as a direct result. To reduce the undesirable large Work in Process (WIP) created by large projects, break them into smaller projects (or at least deliver smaller product increments) organized around MMFs.

3. Manage the On-Ramp. Is your organization is starting more projects than it's completing? This might a sign of improper project kickoff discipline that could lead to future project delays. Obviously, not all projects are alike and it is possible to end one large project and correspondingly start up several new smaller ones in its place, but this metric can still serve as a potential warning device and leading indicator of delays to come. To manage the project “on-ramp,” create a lightweight but disciplined project prioritization process to kickoff projects, and follow it stringently.

4. Create Stable Teams. To maximize project throughput, an organization should only start as many projects as available teams. Instead of sinking costs into forming teams for projects only to break them up on completion, smart organizations create stable teams as high-performance units focused on one project at a time. Each team is as fully cross-functional as practical, containing business analysts, development leads/designers, developers, testers, and perhaps a tools support person. An organization may also have separate dedicated support teams. You can then pull projects from a prioritized project backlog of selected projects and allocated to the appropriate team. The team focuses on this project alone to the extent possible and in working closely with the business sponsor, should be able to finish it way faster than in traditional environments. When the team completes the project, puts the system into production, and hands the maintenance over to the maintenance team, the team will then be available to start the next project. Create stable teams by dedicating core team members at least 80% to the project at hand.

5. Track and Control the Flow of In-Flight Projects. Projects are typically measured along the triple constraints: scope, schedule and resources. Using these as sole measures of progress is problematic: Because scope is often variable, schedules are usually assessed through unreliable artifact-based milestones.

The flow of business value in your project portfolio from Initiation, where ideas originate, through Deployment, when value is realized, should be smooth and steady. Variability – so desirable in Agile product exploration – is not a good thing in the project portfolio.

Defining metrics based upon the value propositions of product MMFs can provide much better indicators of progress. Rather than focusing on project constraints, milestones can measure the realization of product goals. When projects fail to live up to their business cases, as assessed by frequent and thorough evaluations (preferably with real target users), they can be retargeted or cleared from the portfolio. Institute a portfolio prioritization and control process that is based on the delivery of business value, and use it to relentlessly reevaluate projects in-flight and keep WIP in the form of in-flight projects to a minimum.

Get your portfolio flowing, and get started on the journey to low variability, high throughput and high value by applying the five steps above.

When PMI Introduced the Elephant - Part 1

Last October I entered the Gaylord National with a little trepidation. The PMI North American Congress was taking place and I found out that several people I admire in the Agile space were going to be attending and speaking. Leading up to the major PMI event, I was hearing a lot of chatter about these "heretics" who were going to be presenting. In Washington DC, the PMP was king and few in the Federal space wanted to hear anything about adaptive planning, continuous elaboration, or focusing on delivering value to the customer. Project Managers were expected to predict the future, define process and then make damn sure you followed it, regardless if anything ever got delivered. So, I was very much surprised as I walked through the Gaylord and noticed poster after poster, display after display. "Are you Agile?"

Every Agile session I attended, PMI Vice President of Information Technology, Frank Schettini introduced the speaker and told the audience that he leads the team that is responsible for delivering value to PMI’s members, volunteer leaders, certification holders and staff through innovative and reliable technology solutions. He said that he was a strong supporter of the Agile Community and so was PMI.

Though the audience at one of the first Agile sessions was almost hostile towards the presenters, by the time Michele Sliger gave the final session on the final day, there was buzz in the halls of the Gaylord about how "this Agile thing" had taken the conference by storm.

While I was there at the conference, I was privately asked if I would be willing to assist PMI with the creation of an Agile certification. I was very apprehensive, at first. I didn’t want PMI "hijacking" Agile. I was assured that was not the case. I discovered those I respected most in the industry were already hard at work, making sure it was done right.

Agile was about to cross the chasm and PMI was going to make sure we made it to the other side.

But first, introductions were in order.

Four Steps to More Effective Agile Retrospectives

It’s no secret among agile practitioners that retrospectives, as commonly practiced, tend to suffer from a fatal flaw: inaction. Teams discuss all that irritates, perhaps cheer each other on a bit, and then leave the retrospective with faint hopes that things will improve, eventually losing faith in the activity due to its obvious ineffectuality.

The simple solution is to choose a single high-value issue each sprint, and allocate the time necessary to solve it. Some practical ways to make this happen are:

1. Set expectations properly: Ensure that your stakeholders expect a bit of effort toward process improvement and understand the value this brings, both generally and in each case.

2. Keep things small: Improvement actions should go in your backlog. As with other item, they work best when they're able to be complete in about one to three days. If the action is too big or too broad, break it down into smaller, more manageable items.

3. Gather observations continuously: Much time in retrospectives can be spent just raising issues, which reduces the time available to craft and refine solutions. Keep an ongoing backlog of observations (and any suggested actions) that team members contribute to in real time, and this will help jumpstart meetings.

There are many great models for retrospectives available, and we've found that while there's no one perfect structure for all situations, there are some consistently effective patterns.  Perhaps we'll explore these in a future post.

- Arlen

Slides from Agile Palooza DC

Every now and then, one of my presentations seems to be more of a hit than others. The past keynote at Agile Palooza DC is one such occasion. I've had many requests for a copy of the slides, so here they are.

Please do share your thoughts and comments below.

Sanjiv

Building Quality In

Building Quality In

In waterfall development, there is little opportunity for early testing. Most if not all of the delivery happens near the end of the project and this is a really bad time to find out that we have requirements issues, quality issues, performance issues, deployment issues, etc. One of the great advantages of Agile is in its ability to delivery early and often. This early delivery capability leads to an ability to start testing much sooner than usual. Early and frequent testing is critical to quality and agile's ability to support this early delivery model is one reason why agile projects often have lower production defect counts that systems built using traditional methods. However, what happens when you test early and you start to find a lot of defects? How should you handle that situation? Or should you even try to handle it? Perhaps this is to be expected given the fast delivery pace that agile demands. We think not. We are of the opinion that ...

A. Defects are very costly and are to be avoided where possible

B. Lean Thinking teaches us to build quality in

B. Many defects are actually the result of miscommunications and misunderstandings

C. There are simple techniques that can help

A. Defects Are Expensive.

Let's walk through the sequence of events when a typical software defect is found.

1. The developer writes code that it isn't going to pass through test and delivers it to testing

2. A tester finds the defect

3. The tester logs the defect in the ticket system

4. The developer tries to re-create the defect

5. Once found, the developer further investigates it

6. The developer, tester, and business analyst now have detailed discussions about how the feature should work

7. The developer re-codes, re-unit-tests, re-builds, and re-delivers the fix to the test environment

8. The tester verifies that the bug has been resolved and closes the ticket.

Wow! That's a lot of activity that would take up a lot of time for even the most trivial bugs. If teams are producing a lot of defects then this represents a huge 'quality debt' (kind of like technical debt) that will need to be paid back out of the velocity of future sprints. Either the team will need to hold back some amount of time from future sprints to work on defects or they will need to add additional sprints to deal with the quality backlog. So what can we do with our teams to better this situation?

B. Lean Thinking and Quality

There are a couple of different approaches to Quality in general. One way to deal with quality is to simply let defects happen and then rely upon quality control and testing to find the defects. This tends to be the standard approach. We don't think too much about quality until we enter the testing cycle and then we rely upon our testers to find the issues. The problem with this approach is that it is very expensive in terms of time as we have already discussed. Each defect will need to go through all of the steps that we outlined above. And who knows whether or not we will actually find all of the defects.

The Lean world has a different approach; build quality in and create continuous flow. In this model, we do everything that we can to keep defects from entering the system in the first place. By putting some additional controls in the up-stream process steps, and by giving the team members the ability to "stop the line", we can keep many of the defects from ever entering the product in the first place. This tends to greatly improve quality and also improve schedule performance since defects are so costly in terms of time. It also aids in continuous flow since you cannot get reliable forward flow when you are always having to go backwards to fix things. This is the approach that we will further explore. In order to keep defects out, we will need to think a bit about where defects come from.

C. Many defects are the result of miscommunications and misunderstandings

The US Constitution is only about 4000 words long. But to interpret it, we need 9 of the brightest and most educated legal scholars in the land who, at the end of the day, still cannot generally agree on what it means. These 9 people can read exactly the same document and come away with N number of interpretations, none of which exactly match each other. The same thing happens on software development projects. We can write the most beautiful, detailed, and highly elaborated requirements documents the world has ever seen and yet I am sure that if we gave the same document to 4 different software developers, 3 different testers, an architect, and a handful of end-users, we would come up with wide array of interpretations. So while the document may be of some importance in and of itself, it is in the end, insufficient. This is one of the reasons why we value people and interactions over documents!

Many of what we end up calling software defects are really just misunderstandings about requirements. The BA writes the requirement with one meaning in mind, the developer interprets it slightly differently, the tester interprets it in yet another way, and who knows whether or not any of them understand it in the way that the end-users want to see it work. And the funny thing is that the developer's unit tests will always pass because the tests are written against the developer's own assumptions!

The User Interface is another source of a myriad of little 'defects'. It is notoriously difficult if not impossible to write a UI requirements specification that completely and accurately captures every nuance of the user experience. I don't know that we yet have the tools and taxonomy to adequately communicate the user experience. So it is not uncommon to see a plethora of UI related defects for any system involving new UI development.

Another area of concern is that developers actually have at least 3 sets of requirements but they are typically only given 1 of them up front!

1. The Requirements Document or User Story: Yep, the developer usually has something to work with here.

2. The Tester's Test Plan / Approach: It is rare for the developer to see this in advance yet the code has to pass test in order to be released

3. The Customer's Acceptance Plan: It is rare the developer to see this in advance too yet we usually ask our product owners to 'accept' the solution before it goes into production

It is interesting that there are at least 3 sets of "requirements" that must be met and yet we tend to only have one of them defined in advance of development. The agile community is certainly getting better in terms of trying to define "acceptance criteria" up front but we still have a long way to go.

So how do we deal with all of this requirements uncertainty?

D. There are simple techniques that can help

I had the great pleasure of working with Jeff "Cheesy" Morgan a while back on a consulting engagement and we worked together to put some defect prevention steps in place that I will outline here. This is just a sampling of what is possible and there are certainly other techniques out there. The goal behind all of these tools is to either keep defects from entering the sprint in the first place or to at least keep defects from escaping the sprint once they are found.

1. Requirements Maturity Definition

If you've been in the agile community for any length of time, then you have certainly seen your fair share of inadequate requirements. And while even though we know that the requirements themselves will be insufficient, some level of requirements maturity is desirable. Some teams will create a "definition of done" for requirements that can help to make sure that poorly thought out requirements do not enter the sprint and end up being the source of a bunch of defects. For example, a story might need to pass the following basic criteria before being allowed into the sprint.

• It is testable and estimable
• The story has been decomposed to the point where it is less than N points in size
• The basic UI elements have been defined and are available
• The basic business rules have been defined and are available
• The customer's acceptance tests are defined

By defining a basic level of maturity for the requirements themselves, we can help to ensure that enough details are known that the team has a reasonable likelihood of success in delivering the feature.

2. The Three Amigos

As we have discussed, even the best of requirements are open to interpretation. A practice that I like and that is growing is the use of what we call "The 3 Amigos Meeting". The 3 Amigos is an informal discussion between the person who wrote the requirement, the person who is going to be doing the coding, and the person who is going to be testing the feature. These 3 roles get together and discuss the story in some detail to make sure that they are all on the same page about what the requirement means, what the special cases are, how we will test the feature, how it should behave under special circumstances, how error conditions should be handled, etc, etc. At the end of the discussion, we will should have a much richer understanding of how the feature is going to work and most importantly, the 3 Amigos will all be of the same mind with regards to how this feature is going to work. The result should be greater understanding, less confusion, fewer misunderstandings, and fewer defects. We have this discussion for each feature/story in the sprint prior to development.

3. TDD

Test Driven Development is a powerful technique that turns the whole quality issue upside down; quality comes first. When we define in some detail how we are going to test a piece of functionality, what the test cases will be, what the data inputs will be, what the expected outputs will be, etc, we are actually specifying the true requirements in great detail. When we then code to the test plan, we are really coding to the detailed requirements. Not only do we typically get better quality, we also get automated test procedures and detailed testing plans. TDD is a powerful practice that, while difficult for many teams to implement, typically pays off in many ways.

4. In Flight UI Review

How often do you perform a demo to your stakeholders at the end of an iteration only to get a hundred little comments/change requests related to the user interface? This can be maddening for team members and clients alike as they try to identify, manage, and resolve all of the little things that often come up as a part of UI reviews. The UI is notoriously difficult to get right on the first pass; it is an inherently iterative activity that begs for a more collaborative process. We used to have a saying that I still like very much: "The demo should not be the first time that the customer has seen the feature!". While Scrum does demand that we perform product demos after each sprint, that doesn't mean that we have to wait until the end of the sprint to get feedback. For UI work especially, we should be collaborating with our product owners frequently throughout the sprint to catch all of those little subtle issues/changes that could be addressed right on the spot. Waiting until the end of the sprint to catch these can result in a truckload of annoying little change requests that could have been avoided.

5. Pair Programming

Like TDD, pairing is a powerful technique that pays back benefits in a variety of ways. And like TDD, it can be difficult to implement. There is a lot of existing bias against pairing, but if you can get it going, you will likely see improvements in product quality, improvements in code quality, expanded understanding of the product and the technologies by the team, cross training, elimination of single team-member dependencies, shared code ownership, etc.

Closing

The traditional approach to quality is to let bad things happen and then use various QA activities to find those defects and tease them back out again. We let bad design happen and then use design reviews to find the problems; these will need to be fixed resulting in rework. We let bad code happen and then use code reviews to find the bad coding practices; these will need to be fixed resulting in rework. We let defects enter the system and then we use testing to find the defects which will need to be fixed resulting in rework. You get the idea. The Lean model is to find where defects are entering the system and to put what are often simple steps in place to help to keep defects from ever entering the system in the first place.

Roland Cuellar