How to choose the right project? Decision making frameworks for software organizations

Frameworks to choose the best projects in organizations are a dime a dozen.

We have our NPV (net present value), we have our customized Criteria Matrix, we have Strategic alignment, we have Risk/Value scoring, and the list goes on and on.

In every organization there will a preference for one of these or similar methods to choose where to invest people’s precious time and money.

Are all these frameworks good? No, but they aren’t bad either. They all have some potential positive impact, at least when it comes to reflection. They help executive teams reflect on where they want to take their organizations, and how each potential project will help (or hinder) those objectives.

So far, so good.

“Everybody’s got a plan, until they get punched in the face” ~Tyson

Surviving wrong decisions made with perfect data

However, reality is seldom as structured and predictable as the plans make it out to be. Despite the obvious value that the frameworks above have for decision making, they can’t be perfect because they lack one crucial aspect of reality: feedback.

Models lack on critical property of reality: feedback.

As soon as we start executing a particular project, we have chosen a path and have made allocation of people’s time and money. That, in turn, sets in motion a series of other decisions: we may hire some people, we may subcontract part of the project, etc.

All of these subsequent decisions will have even further impacts as the projects go on, and they may lead to even more decisions being made. Each of these decisions will also have an impact on the outcome of the chosen projects, as well as on other sub-decisions for each project. Perhaps the simplest example being the conflicts that arise from certain tasks for different projects having to be executed by the same people (shared skills or knowledge).

And at this point we have to ask: even assuming that we had perfect data when we chose the project based on one of the frameworks above, how do we make sure that we are still working on the most important and valuable projects for our organization?

Independently from the decisions made in the past, how do we ensure we are working on the most important work today?

The feedback bytes back

This illustrates one of the most common problems with decision making frameworks: their static nature. They are about making decisions "now", not "continuously". Decision making frameworks are great at the time when you need to make a decision, but once the wheels are in motion, you will need to adapt. You will need to understand and harness the feedback of your decisions and change what is needed to make sure you are still focusing on the most valuable work for your organization.

All decision frameworks have one critical shortcoming: they are static by design.

How do we improve decision making after the fact?

First, we must understand that any work that is “in flight” (aka in progress) in IT projects has a value of zero, i.e., in IT projects no work has value until it is in use by someone, somewhere. And at that point it has both value (the benefit) and cost (how much we spend maintaining that functionality).

This dynamic means that even if you have chosen the right project to start with, you have to make sure that you can stop any project, at any time. Otherwise you will have committed to invest more time and more money (by making irreversible “big bang” decisions) into projects that may prove to be much less valuable than you expected when you started them. This phenomenon of continuing to invest beyond the project benefit/cost trade-off point is known as Sunk Cost Fallacy and is a very common problem in software organizations: because reversing a decision made using a trustworthy process is very difficult, both practically (stop project = loose all value) and due to bureaucracy (how do we prove that the decision to stop is better than the decision to start the project?)

Can we treat the Sunk Cost Fallacy syndrome?

While using the decision frameworks listed above (or others), don’t forget that the most important decision you can make is to keep your options open in a way that allows you to stop work on projects that prove less valuable than expected, and to invest more in projects that prove more valuable than expected.

In my own practice this is one of the reasons why I focus on one of the #NoEstimates rules: Always know what is the most valuable thing to work on, and work only on that.

So my suggestion is: even when you score projects and make decisions on those scores, always keep in mind that you may be wrong. So, invest in small increments into the projects you believe are valuable, but be ready to reassess and stop investing if those projects prove less valuable than other projects that will become relevant later on.

The #NoEstimates approach I use allows me to do this at three levels:

• a) Portfolio level: by reviewing constant progress in each project and assess value delivered. As well as constantly preparing to stop each project by releasing regularly to a production-like environment. Portfolio flexibility.
• b) Project level: by separating each piece of value (User Story or Feature) into an independent work package that can be delivered independently from all other project work. Scope flexibility.
• c) User Story / Feature level: by keeping User Stories and Features as small as possible (1 day for User Stories, 1-2 weeks for Features), and releasing them independently at fixed time intervals. Work item flexibility

Do you want to know more about adaptive decision frameworks? Woody Zuill and myself will be hosting a workshop in Helsinki to present our #NoEstimates ideas and to discuss decision making frameworks for software projects that build on our #NoEstimates work.

You can sign up here. But before you do, email me and get a special discount code.

If you manage software organizations and projects, there will be other interesting workshops for you in the same days. For example, the #MobProgramming workshop where Woody Zuill shows you how he has been able to help his teams significantly improve their well-being and performance. #MobProgramming may well be a breakthrough in Agile management.

Picture credit: John Hammink, follow him on twitter

Hire generalists to help your specialists shine!

Imagine you are developing a highly-specialized embedded software product. Like a radio tower for the GSM/UMTS network, or a high-frequency trading back-end for a large New York trading firm. Why would you want to have generalists in that team? After all, these are niche-niche-niche products. Maybe a few thousand people work on these projects in the world. No need, right? Wrong! Here's why.

Forget common-sense

The comment above is designed to sound counter-intuitive. The reason for that is that most of this post is counter-intuitive. I'll argue that one of the basic premises behind software project management are purely and simply wrong. This one specifically, is ultra-wrong: specialists in a software project (even a niche one) should be the majority of the team. The "favor specialists" heuristic says things like: "don't hire a Ruby programmer to a Java project", "hire only people who've done financial systems to that high-frequency trading platform", etc. You get the picture.

What is the reason for this "favor specialists" heuristic? Why did it arise? The most obvious reason is that we want to hire people that "know what they are doing", and in our functional definition of software projects that means: "people who have done that one thing before". And who could argue with that? Right?

What if we looked at projects like systems, complex systems that incorporate technical and social aspects that are very hard to control or manage? In this case we would be compelled to question the "favor specialists" heuristics, because we would look at a project as much more than a technical endeavor. We would look at projects as being social and technical endeavors.

Social is complex

Social systems have many more dynamics in place than "what is the best technical solution? How do we select from competing technical solutions? What skills should we hire for?"
Social systems change rapidly (whether you like it or not), and they require a different set of assumptions about what is the best project team composition and organization. For example - the point of this post - it requires us to question the ratio of generalists to specialists.
In the last post I talked about Emergence. I explained that system behavior is affected by many unpredictable dynamics and that simple rules favor adaptable behavior in projects. I also said that a long list of complicated rules will remove adaptability from the project team. The heuristic I described in that post is: "complex rules emerge stupid behavior."

Emergence is favored by and favors generalists

I believe all projects are social complex systems. Yes, even two people projects (those, probably even more than larger projects. Think of the rule set on a 2 people project!). These social complex systems perform better when there are only a few and simple rules. They benefit from constant change (see here how to do that so that it does not kill you). Social complex systems are environments where generalists excel! Here's why:

• generalists are more likely to think laterally (similar problems in other domains), and therefore come up with innovative solutions that provide business advantages;
• generalists are more likely to establish communication links to other teams and organizations (because they are connected to more interest groups - which is what makes them generalists), and therefore improve the overall communication in the project team;
• and there are many more, let me know which you have found in your experience by leaving a comment.

Improve performance by adding generalists to your project

I propose that we start designing our projects based on a different heuristic: "favor generalists". This means that we will try to seed all teams with generalists, people who know their trade but are not invested in only one particular technical solution or process.

For Developers this means that all developers should be encouraged to learn several programming languages, work in different problems during their employment, and that we don't hire people just because they've solved the same problem in the past.

For Testers this means that we hire people that can do manual and automated testing (maybe more on than the other, but both), that know different technologies, that understand social aspects (users) and technical aspects of software development (e.g. math).

For Product Managers this means that we hire people that have worked in other industries, other types of products or even in non-software only products.

If you believe, like I do, that software projects are social complex systems, then you must not favor specialists. Hire and groom specialists but seed all teams with generalists, sit back and enjoy the higher performance.

Picture credit: John Hammink, follow him on twitter.

How injecting randomness into your project can help it succeed

Success and failure differ, very often, by very little. Take nature as an example. A small change in our DNA (a few mutated genes) can have catastrophic consequences. On the other hand, without these mutations humans would never have come into existence.

Humans and other species in the planet evolved because of chance (although not totally chaotic) changes in their DNA. As small change after small change happened, the surviving individuals were able to spread the viable, and ultimately the most adequate changes to the next generation - and the process repeats still in our own bodies today. If Nature has taught us something about improvement and evolution is that you must have a little bit of luck involved!

The DNA of a project

In software projects - my domain - I see some similarities to this natural model that are worth exploring. Projects also have a DNA which includes the structure and the communication connections between individuals. Communication being one of the most quoted causes for failure in software projects, and therefore one of its critical success factors.

The More I Practice the Luckier I Get

Once a project gets started, a particular structure is put in place (governance, management, teams, etc.). Very often that structure remains in place, and static until the end of the project. But is this a smart choice?

Another aspect of the project that rarely changes is the network of connections between the individuals. This network is what carries information from individual to individual and eventually "selects" the information that is acted upon by the project team. If a piece of information reaches an individual in the project, and that individual does not consider it relevant, that information will not spread further. In contrast, when a piece of information is perceived as important by an individual, that information will be actively spread by that individual.

The Illusion of Control

The structure that is set for a project strongly influences the communication links that can emerge between individuals. Who talks to whom? What meetings exist where people interact regularly? etc. But the reverse is also true. The existing communication network within an organization is a strong influence on what governance structure is put in place, how teams are formed, etc. These co-dependent processes create a positive (or negative) spiral of events for the project, but because neither (structure, or communication network) is often changed, that spiral is unstoppable. If it is positive, it will help the project succeed. If this co-dependent processes create, instead a negative spiral, that will relentlessly remove the chances of success for that project.

This co-dependent relation between two key processes (structure and communication network) is why we can increase the chances of success in our projects by simply causing random perturbations in the project. Randomness helps us explore different patterns for structure and communication networks.

As we carefully design and inject small - safe-to-fail - changes into the project, we can observe how it reacts and adjusts. Later, we can retrospectively amplify or remove/dampen the changes based on the outcome we see. If something works, keep it and ask how can you make it grow. If something creates a net negative outcome, dampen or remove it completely.

The cycle goes like this:

• Define and implement small, safe-to-fail changes in the structure or communication network for the project
• These changes lead to emergent behavior as the individuals and teams adapt to the changes
• A new project configuration emerges which drives new project results
• Finally, we evaluate the results of these changes and decide which components we will try to amplify or dampen

What Do You Mean Random?

There are many ways in which we can, randomly, explore better configurations for our projects. Below I list only a few to illustrate the concept:

• At the start of a project, let the teams chose their own composition. This establishes new connections between individuals in the project as some will choose to work with new team members. However, these new connections will not eliminate the previous connections between individuals. The net effect should be that your project now has a more connected communication network (more individuals with strong connections to each other). In practice this works just like when we form new neural connections in our brain: more connections leads to different thinking and acting patterns
• Organize common project events where people interact with each other outside the day-to-day routine. Planning events can be organized following a structured approach, but including also some unstructured time (à lá unconference, using e.g. Open Space) where people can interact based on their interests. This will also help form new connections between individuals in the project and spread information that would otherwise be locked down and not accessible
• Have regular project "coffee breaks" that happen at the same time and same place. In these events people can connect with other individuals and ask questions from the project management team or the most connected individuals in the project. This unstructured communication increases the chance that some piece of information will "jump the hierarchical borders" and reach people in decision-making positions, or people with influence that can later act on that information.

Conclusion

These practices are designed to inject randomness (unplanned situations or connections) into the project. The goal is not to create Chaos (a scary word for many project teams), but to generate new pathways for the information to flow within the project team, as well as novel project structures that are more adapted to the current challenges the teams face.

Using these (or other) practices will increase your project's chances for success. They don't eliminate the need for the project to be managed, or to have structure. They do increase the chance of success for the project by exploring new organizations and structures through a process of small (safe-to-fail) changes that can lead to unplanned, but ultimately superior performance.

These were just a few examples. How would you inject randomness into your project? Have you done that in the past? Please share your experiences in the comments for the benefit of others.

Photo credit: John Hammink, follow him on twitter

Which do we need the most, Project Managers or Line Managers?

Should we organize around the delivery of products or along the structure of our organization? Which organizational paradigm is the most effective or efficient?

This is a question that most managers struggle with regularly. At least when they are asked to "re-organize" their respective organizations.

In Europe (and I suspect elsewhere) this has led to a huge growth in what I would call Hybrid organizations. Also known as "Matrix organizations". These are organizations where managers try to blend delivery-focused (project) organizations with hierarchical-focused organizations (the line organization).

Which organization is better?

Just this week I had an argument with a colleague about this. Which of this organizational paradigms is better? It is my view that both of these options, actually all three (if you count the matrix organization) represent a fundamental lack of understanding of how knowledge work happens and how it gets done.

The Hierarchy-focused organization is based on the principles that we need to have someone to "manage" the worker. As if the worker herself would not be able to make decisions about allocation of resources or conflict resolution without the contribution of a higher manager.

The Project-focused organization is based on a similar principle, the principle that the worker cannot make execution-relevant decisions herself. For example, which piece of work to do first, or where to get some necessary information.

The Matrix organization may be based on both of these ideas, i.e., that the worker cannot do any type of decisions herself...

I believe these principles (and the associated practices) are wrong. I believe that we can have organizations that are focused on delivering concrete products / services to the customers without having to have any of these layers to "manage the work and the worker".

Why should we have Project Managers and other interesting arguments...

My colleague was arguing that we don't need Project Managers in an organization because they don't deliver anything. "They are overhead that produces no value outside coordination" he said. Sure, I can buy that, but what do line managers do that cannot be classified in the same way? The answer is nothing. Line manager's work is mostly overhead as well. They don't - on their own - deliver anything to the end customer, and do mostly coordination work (for example: coordination of performance reviews).

So the question is: If we believe that Project Managers "add no value" to a knowledge organization, why do we have line managers?

What do you think would be my colleagues answer to that question?

Photo credit: miuenski @ flickr

Using #NoEstimates when deciding which projects to take on

One of the questions (Part I, Part II) that emerged from the #NoEstimatesQuestions discussion on twitter was: “How do I choose between options or opportunities (without having estimates regarding the cost)?”

The thinking goes: I can spend some time doing A or B, but which should I do first? To answer this question we can look at it from two angles:

• 1) How much does A or B cost and how long to they take?
• 2) How much will I learn from doing A or doing B? Which knowledge is more important for me now?

The first point of view assumes that both A and B have similar value (or Return) and that the investment part (the I in ROI) is the most important factor. I happen to think that in software this is not the case. In my experience the R (Return in Return On Investment - ROI) is often more important than the Investment in defining the overall value of a certain decision. In my experience, the second approach will help you make a better decision when selecting between different options. Asking yourself "what is the value I expect to get from option A or option B?" is often a much more insightful discussion regarding the Business Model for your product or service. Here is how I would answer the question: “How do I choose between options of opportunities (without having estimates regarding cost)?”

• Step 1- Define what you expect from doing A and B. Example: A) If I implement “login in with facebook” I will expect to have more users to access the site due to the simpler registration. B) If I implement “invite a friend” I expect to have more visits to the site and ultimately more people registering than if I choose A.
• Step 2- Now, break the work down into risk-neutral chunks (i.e. chunks that don’t kill your project if you fail to reach the expected goal). This leads me to goal decomposition: given that I can’t test any of the options by tomorrow, is there something that I can test by tomorrow which would help me choose futher? Can I implement the “invite a friend” feature by tomorrow? Yes: great! lets do that. The reason is simple: by tomorrow I can start to test option B, if I had gone with Option A I would have to wait longer to be able to test my expectation.
• Step 3- Now it is time to get to work, deliver the smallest/easiest possible implementation of “invite a friend” by tomorrow, and review the impact of that feature. Once this functionality is live you can can either continue with B (if more changes are needed), or ask yourself what are the next options you need to decide on.

How to tackle Large Problems(™)

The example above will, rightfully, called a “simple” problem. So, the next question is: what if I have to decide between 2 Large Problems(tm), which can take several years of development and months of deployment? For example:

I work in the Ministry of Health and I need to decide between developing a large system to manage the health-care records of 10’s of millions of people, or maintain an existing system with potentially huge costs.

In this environment the Return part of the ROI equation is not easily accessible. In fact, one could argue that in this type of projects the I (or Investment/Cost) is the most important factor in making a decision. Most governments do that and spend considerable amounts of time estimating the costs of both options (with terrible consequences). #NoEstimates asks for a completely different approach to these problems (where cost is the key factor in deciding). In fact I would work to completely eliminate the “develop new system from scratch” option from the table. The reason is simple: we are terribly bad at estimating large software projects, so we should avoid them completely. Instead, we must use the flexibility of software to our advantage: start small and slowly grow the team as well as the final technical solution. How I would do it:

• Step 1- Determine what is the most operationally critical part of the system (e.g. by number of people assigned to work on that part of the system, or by contingency plan size -- don’t spend time estimating criticality, there is plenty information already available). Don’t start by changing this part of the system - it is far too critical (as you just determined). Select any other part of the system that you can change without any long-winded approval processes (random selection is ok, but you probably have a hunch).
• Step 2- With a small team (say 5-7 people) start a 1 week project to change this part of the system (a new version of the same software, including tests to ensure that the new implementation works as expected). Can’t do it in a week? Select a smaller part of that system component until you can. Don’t bother estimating, just ask the team until most agree it can be done. In parallel start listing, every day, other system components you will need to change next. Use the ideas in Step 1 to prioritize that list. By the end of week #1 you will have the first “changeable system component backlog” (don’t worry about the comprehensiveness of this list, you will update it every constantly).
• Step 3- By the end of week #1 you should have a small part of the system component re-implemented to the new standards (maybe a new technology? maybe a new privacy law?). Now ask, how many such components do you have to change to complete the project. 10? good, then it will take 10 weeks or so (don’t worry about being right, you will update your projections as you go)
• Step 4- Take the next part of the system and start another 1 week project. Later you may want to start more than one part of the project by adding one more team. But don’t add all teams at the same time

In this approach we try to achieve the following:

• Evolving understanding of the system in terms that can be used for data-driven progress projection (a- changeable system components backlog, b- how many system components can we change per week?)
• An evolutionary change to the system in a way that the system is always functional and the project - even if stopped prematurely - constantly delivers value to the owners of the system (in this case the taxpayer).

Conclusion

I’m sure that there are still quite many questions about the steps and approach I described here. Leave those questions below so that we can continue the dialog.

The #NoEstimates questions, Part II

Last week we did not cover all the questions on #NoEstimates. Twitter gave us a lot more questions than could be listed last week, and even more interesting ones. Read on for the questions and my take on their meaning.

How do I choose between options or opportunities (without having estimates regarding the cost)?
• Choices are hard to make. When you are deep into the development process you inevitably come up with many ideas. But how should we choose between all those ideas without a detailed estimate? I believe this question implies that we have no way to assess the opportunity cost of selecting one of the options. I propose we challenge this assumption in a later post.
How to win a government contract without estimates?
• A very common question, also present implicitly in last week’s post when a questions asked: How to practice #NoEstimates in companies where estimates are "mandatory"? When the legal framework (or contract) requires you to provide an estimate of the length of the work you just have to do it, of course. But a more interesting question to tackle will be: how do we use #NoEstimates to our own (and the customer’s) benefit even when we have to provide estimates before we can win the contract?
What visual indicators do you have in #NoEstimates to show if you deviate from the "optimum"?
• Are we going in the right direction? Are we progressing towards the goal? Do we have the right features? Will we be on time? There are many implicit questions behind this one. While exploring the answers to these questions, I hope we can generate “heuristics” that are relevant and actionable for people interested in the “end game” for a project or a delivery. Including heuristics based on visualization.
Will #NoEstimates give me better predictability even when not using estimates?
• The holy Grail: predictability. In my view, the temptation is to say: if you have time-boxes you don’t need more predictability, you already have it. However, I think this question goes beyond “delivering on time”. In fact, I believe that this question is about predicting “everything” (scope, quality, cost, length, …) We have to explore what #NoEstimates can help with, and what it can’t help with when it comes to looking into the future.
If I just "play the game" with project managers and give estimates that I know aren't right, am I already doing #NoEstimates?
• This question is perhaps related to the one above where we tackle how to use #NoEstimates in an environment where we are asked to provide estimates. It must be said that lying (providing information you know not to be true) is not right, deceiving is not right - no matter what method you use to manage your projects. I hope to clarify how my practice of #NoEstimates can help you tackle the estimation requests you get, but still benefit from the added information #NoEstimates can provide.
Is there some analogy between SQL/NoSQL and Estimates/#NoEstimates?
• Many people comment on the choice of tag (#NoEstimates) for this wider discussion on estimating and managing projects. It is true that if you look at the hash tag used and the previous SQL/NoSQL discussions there is a similarity in the surface. However, I think there are further similarities between these two movements. I’ll explore those in a later blog post.
Does #NoEstimates aim to change existing social constructs (e.g. capitalism, budgets) to remedy the need to estimate?
• As far as I understand this question explores the possible impact and consequences of #NoEstimates, including on the budgeting cycle and the business models. I don’t think #NoEstimates tries to tackle business models at all, in fact I think it aims to enable more business models. On the other hand, #NoEstimates does try to change the way we look at budgets - project budgets at least - with the aim to make those more transparent and reliable. This topic promises to be very interesting as it has generated a lot of discussion on twitter.
Is it accurate to say #NoEstimates is for projects in Cynefin's complex domain?
• For those of you that haven’t followed the Cynefin model or Complex Systems discussion, let me just clarify that Complex Systems are such that causality can only be attributed in retrospect, i.e. we cannot anticipate how the system will react to a certain stimulus, therefore we must experiment (Probe-Sense) and Respond to the results of those experiments. While I believe that #NoEstimates is a perfect fit for Complex environments, I don’t think it applies only in that domain. There are benefits to be gained in other domains: Cynefin/Complicated, Cynefin/Chaotic and even Cynefin/Simple.
If we elect not to take on the risk of predicting an uncertain future, who do we think should, and why?
• I believe this question is trying to answer: Who should take the risk for the (future) results of our actions? Obviously I think we - the people in the project - should take the responsibility for tackling the project in all its characteristics and risk. I don’t think #NoEstimates leads to a shift of the risk carried in any project, and in fact I believe #NoEstimates approaches can be much more effective at uncovering and tackling emergent project threats or risks. More on this later.
Why would we choose not to judge likely outcomes, when worthwhile human endeavors necessarily carry risk?
• My interpretation of this question is that it asks: Should we even look into the future at all? Equating #NoEstimates with #NotLookingIntoTheFuture is a red-herring in my view. I’ll try to explain in a later post how, in my view, #NoEstimates approaches can deliver a much better model of “the future” for any project.
What is and isn't 'estimating' when people form and act on expectations of an uncertain future every day?
• If I remember correctly somebody tweeted: “how can you say “don’t estimate!” when even the act of getting up in the morning requires estimating?”. Perhaps this comment comes from a misunderstanding of the domain we are talking about when we use the term #NoEstimates. It is important to state that we are using #NoEstimates in the context of estimating large software endeavors (i.e. projects), not simple tasks or even fixed/variable-costs calculations (e.g. servers, bandwidth, person-hours, etc.).

This is the list of questions that I’ve collected in the last few weeks on twitter. I hope to answer them here on the blog with your help. Please contribute to the prioritization of these (and last week’s) questions by leaving a comment below with the questions you’d like to tackle first.

Once prioritized, I’ll start answering those questions and we can have a longer discussion about each of them here. After all, twitter, is a great conversation starter, but we need blogs to develop them further ;) Photo Credit: Brad Hoc @ flickr

Patterns of Agility. How to recognize an Agile project when you see one...

Instead of fighting about "who's agile" or "who's more agile than whom", it would be useful to create a set of patterns, that once recognized would help us define if we are or have been able to successfully implement an Agile life-cycle for our project and portfolio.

These patterns or symptoms are useful for us when analyzing a project (e.g. for a retrospective) and assessing the progress of a team or a company from waterfall to Agile software development. These are necessarily only a small collection of patterns. Many more are needed to create a complete language that would help us define better what an Agile project should feel and look like.

Before getting deeper into the patters let me define at the outset what I mean by life-cycle. In my context life-cycle refers to a stage/phase in the life of a project. Example: a project that is "about to end" is in a different life-cycle phase than a project that is "about to start" or "ramping up". I define the following useful, although not exhaustive, life-cycle phases: Start, Middle, End.

In the following text I try to define what different types of projects (Waterfall, Linear Iterative and Agile/Incremental Iterative look and feel like.

Waterfall

Life-cycle phase: Start

In this life-cycle phase a waterfall project is typically in a phase where only the project management team is assigned to the project and the goal is to create a plan. The plan is typically composed of a set of requirements, an architecture target (maybe an architecture plan or just a high-level picture to be developed further), a budget and (most importantly) a project plan.

You know you are in a waterfall project when in the life-cycle phase Start you are mostly spending time in front of a presentation or word editing software and have some meetings (maybe weekly) where scope, budget and project plan are discussed. This phase typically ends with a "gate" where the project plan and Requirements + Architecture are approved.
A dead give away of a waterfall project is that, in this phase no one asks or worries about writing a single line of code. Some sophisticated waterfall projects may include a "prototype" in the life-cycle phase Start, but it will usually be a throwaway and developed by a sub-contractor who will not actually work in the project (after all the other teams are busy with the other projects).

Life-cycle phase: Middle

In this phase the project is in "full speed", which usually means that teams are working with very little coordination (after all they have a "plan" to follow). Typically components are assigned to teams and they work on those in isolation.
A dead give away that you are in a waterfall project is that your team does not integrate code with the other teams at all. Some sophisticated waterfall projects may have "sync-points" or "integration camps" where the component teams come together after a long period of development to integrate their code. These are grim affairs with much overtime and gritting of teeth.

Life-cycle phase: End

In this phase the waterfall project is "code complete" and aiming to "code freeze". There is usually a milestone/gate that was passed exactly at the start of this life-cycle phase called "code complete" or "feature complete". It is at that point that the teams of testers (typically many and in some far away country) are assigned to "test" the product. Obviously what they will be doing is a rather superficial sweeping of the floors to check that everything works. It is only after that that the project can pass the "code freeze" milestone/gate and the real testing can start.
You know you are in a waterfall project when the project runs out of time before it has quality enough to be released. The number of bugs being found is still very high, but probably at about the same level of the bugs being fixed. This is when "management" comes in and pushes all the teams to fix as many bugs as they can (pulling all-nighters or all-week-enders if needed). Much motivational language is used but the count of bugs being fixed stays about the same. The project will eventually ship something, but the actual quality level can only be vaguely understood. Business takes precedence in the decision making.

Iterative, aka Linear Iterative

Life-cycle phase: Start

In an iterative project the Start phase will typically be called Inception and will, like the waterfall projects focus mostly on defining requirements and creating/approving the project plan.
You know you are in an iterative life-cycle project when people start actually coding, but only a few features. Programming is still being "ramped up", but there's no milestone/gate that formalizes "start-programming" order.
In some sophisticated Iterative projects people will mention Use Cases, customers, experience, business cases and may even have a prioritized list of Use Cases to be implemented. Typically you will find that the Requirements document is quite shallow, delegating the clarification of most requirements to the actual "design" phase of the project.

Life-cycle phase: Middle

Now the teams are working very clearly on the code. Some Iterative projects may even have several sync points (see above) within this life-cycle phase. They will be easier than in a waterfall project, but "integration camps" are still common (although less frequent) and teams actively discuss the "code-line" policy (i.e. version control is an active part of project management.
A dead give away of an iterative life-cycle is that there will be several iterations of about 2-3 months in length at which point many teams try to integrate their code. In some sophisticated Iterative projects the teams will actually try to hold demonstrations of the existing code and in some (far fetched) cases there will be a project-wide retrospective at this point.

Life-cycle phase: End

You'd be tempted to think that Iterative life-cycle projects would have an easier "End" phase, but you would be wrong. Just like in waterfall, the teams develop a lot of their code in their own version control systems and integrate seldom (although much more frequently than in a waterfall project). In large iterative projects there will be "vertical" sub-projects (typically less than 100 people) that will actually integrate their code frequently but the multiple concurrent sub-projects will only really integrate their code at the end.
In this type of projects you will still find a very hectic "test and fix" phase at the end, but it will typically be focused around "complex use cases" as many of the simple use cases have already been tested during the "Middle" life-cycle phase.
You know you are in an iterative project because just like in waterfall Quality is an after-thought and you will find many, many bugs in the end of the project. The defect/error metrics will be the main focus of the project management team in this phase, up to the point that sophisticated statistical models will be created to try to predict when the project will end.
Don't be fooled, in a project where error/defect metrics are used as the main project management tool no one is in control. The project end date is essentially unpredictable and typically management will decide (arbitrarily) when the product should be released.
In some sophisticated Iterative projects I've seen that a length is pre-set for this life-cycle phase based on history and, ironically, that seems to hold pretty well (although not for the reasons you may think! -- stuff for another post)

Agile, aka Incremental Iterative

Life-cycle phase: Start

In an agile project this phase is typically extremely short. A product manager will present a proposal for a new product or a new version of an existing product. This proposal will be discussed and approved. One or more teams are assigned to the project for a short period of time (called Sprint or Iteration -- confusing, I know) and produce a running product, called a Product Increment.
You know you are in an Agile project when the team talks about "releasing" the software starting from day one. Each development team will include testers and each Requirement (aka story or feature) will be discussed in order to create acceptance criteria (aka conditions of satisfaction, aka test cases). These will typically be agreed before the team sets out to design the implementation but can also be updated during the Sprint/Iteration.

Life-cycle phase: Middle

In this life-cycle phase you will notice that the teams start to gel (if they are new) and the project gains momentum. The teams demonstrate regularly what they have accomplished and some teams will have stopped holding retrospectives, because they "have nothing to improve". The pressure is always high in an Agile project, but never too high, and in this phase of the project the team is already used to the pressure level, they know how to tackle their stakeholders.
You know you are in an agile project when the Product Manager is not the Product Owner and is never or almost never present in the Sprint/Iteration planning meetings. That work is delegated to someone in the team that knows the technical product and works with guidance from the product management to help the team manage and prioritize their backlog (aka Technical Product Owner).

Life-cycle phase: End

This is the life-cycle in which the Agile project will differ the most from the other two life-cycle models. In the end of the project the team will still be developing new features at full speed. No one will talk about "code freeze" or "feature freeze" in the project, but the testers and project management team will closely follow the Defect list.
You know that you are in an Agile project when the defect/error list is short and the selection/prioritization of defects/errors is easy. Some teams will just start their iterations/sprints by picking the most important defects out of the defect backlog, others will reserve some time/bandwidth in iteration/sprint planning specifically to improve the quality of their product.
The most noticeable difference however, will be that people will feel the pressure to add more features at the end, rather than the pressure to avoid changing any code. Agile projects typically deliver a large amount of "test" code (i.e. code that is there to test the production code) which makes them confident that they can change the code up to the last minute of the project.

Conclusion

I hope that this collection of patterns from different types of projects will help you talk about the level of agility in your project with your team.
We should really stop bickering about "how agile we are" and start defining how an agile project "feels" like. What patterns do we see, what benefits and constraints we have, etc.

At the end of the day, what matters is that you understand your context. That's the first step to changing it!

Photo credit: Bill Gracey @ flickr

What can we learn from illusions that helps us manage projects better?

Just had the opportunity to watch a BBC documentary about illusions.

The show went on to detail how we as humans get deceived by our own senses. There were 3 things that opened my eyes in that documentary:

The things that caused me to think were:

• when we mix senses one of them tends to take over: this is the case when we are watching a magic act. The example on the documentary was a magician throwing a ball in the air for a few times, and then making the same gesture but keeping the ball in his had. Although the subjects eyes stayed on the face of the magician, the brain perceives the movement of the ball and later realizes that the ball has vanished.
  
• some of our senses are completely/100% contextual (see image above): the example they had here is a cube with many small squares on it's faces. Some faces are lighter, others are darker. When asked about the difference between 2 specific squares in the faces of the cube people would clearly state that the colors were different. However, when you moved one of the squares to the other face of the cube, you could see that the colors were exactly the same! Our perception of color was completely dependent on the colors surrounding the colors we were comparing.
  
• we can learn new senses if we are exposed to the right stimuli: The amazing examples they had for this was a blind-person that had learned to use sound and echo to see and used that learned sense to ride a bike (while blind!) The second example was quite amazing. A person would use a belt what was wired with buzzers/vibrators (like mobile phones) so that they could constantly feel where the magnetic north was. Later they would use that learned sense to navigate their way in a place while blind folded!
  

All of these observations from the documentary point to one thing. We are not wired to perceive reality. We jump to conclusions far too quickly, but we can also take advantage of that if we train our brain with the right stimuli! That was the most interesting find from this documentary.

The implications are huge in a software project setting, where it is quite common that people use only a very small number of stimuli (some reports, a couple of graphs, etc.) to jump into conclusions. We need to "learn" how to sense the status of a software project, and that can be done by following the example of the person who was taught how to "feel" the magnetic north...

Can you think of applications of this knowledge in your project?

PMI vs Agile, the debate continues

Prompted by a comment by Murray on my first blog in this debate I wanted to expand some of the ideas that have not yet been explored.

Here are the key excerpts from Murray's comment:

PMBOK V4 is compatible with and supportive of Agile processes. Here are some relevant quotes from CHAPTER 2 − PROJECT LIFE CYCLE AND ORGANIZATION

"There is no single way to define the ideal structure for a project"

"it is up to the project manager and the project management team to determine the most appropriate method of carrying out the project"

"There are three basic types of phase-to-phase relationships:

• A sequential relationship (...)

• An overlapping relationship, where the phase starts prior to completion of the previous one (...)

• An iterative relationship, where only one phase is planned at any given time (...)

The PMBOK v4 is quite recent and I have to admit I'm not familiar with it.
However, PMBOK v3 completely omitted the discussion about phase-to-phase relationship in the way described above.

Another aspect that is seldom discussed is that in IT projects (specifically Software Products) we are very quickly distancing our methods from the project-concept. In companies where I've worked, projects no longer represent in any meaningful way how the company works.

Another caveat is that Linear-iterative projects (like RUP proposed) are significantly different from the Incremental-iterative project structure that Agile methods in general and Scrum specifically propose.

All in all, there are significant differences that warrant a very skeptic look at what PMBOK has to offer.

If you want to check some other views into why the "project" pattern is not necessarily useful for software product development take a look at this blog post by Ari, who has quite a long experience in product companies: "Focusing on projects ruins your business"

Photo credit: Dunechaser @ Flickr

PMI vs. Agile, what is different, and why should we care

The PMI people don't seem to stop trying to "guess" what Agile is. Guessing is the right term, because anyone with more than a few hours experience in Agile software development can see their cluelessness from afar!

Take this article by Lynda Bourne DMP, PMP (no, I'm not making those TLA's up, she uses them). She says that Agile is different from waterfall because:

• The need for robust change management and configuration management to track the evolution of the Agile project
  
• The critical importance of developing the correct strategy and architecture at the beginning of the Agile project

Someone that says that in Agile project management you need "robust change management and configuration management" probably does not even understand what those are, let alone Agile. Hear me out: Change Management is not needed in Agile, Agile *IS* change management. Take Scrum for example, the whole idea with Scrum is to provide a framework for accepting and managing changes. Scrum *IS* change management. To say that Agile project management "needs" strong change management is to miss one of the most elementary points of Agile Software Development.

Then comes the killer: we Agile project managers (supposedly) need to focus on "developing the correct strategy and architecture at the beginning of the Agile project", missing this - Lynda writes - will lead to failure. Only one word: WTF? C'mon Lynda, that is probably the largest mis-conception of Agile Project Management that I've seen in my (admittedly) short life!

There are thousands of posts about why Agile people focus on "growing" architectures rather than "getting them right up-front" (aka BDUF). Please read up, just google for Agile Architecture and you will find many articles that explain how in Agile we look at Architecture development (here's an example link).

There seems to be a lot of discussion happening in the PMI circles about Agile, but PMI people need to understand that the practices they've developed for building, acquiring companies, etc. don't all apply to software. PMI people should first learn about software and then Agile. Trying to bypass software and going straight for an Agile take-over will only get us (the software industry) another 10-years back in time and lose so much of the evolution we gained with the Agile movement.

The hard reality of life as developer...

If any of this is familiar, then you should really be reading this blog! :)

Hug a developer today.

Blogged with the Flock Browser

Belief without proof is dangerous!

Believing in some far-fetched (or indeed any) explanation without having any proof is dangerous. It is dangerous in the case of the flat-earthers and it is dangerous for project leaders and team members.

Whenever a theory emerges why something works (or doesn't) in your project/company, it is your duty to either prove it right or wrong.

Oh, and by the way: yes, it is indeed true that there are still people who believe the earth is flat!