Radical Management

Steve Denning has written a great agile book for managers, called The Leader’s Guide to Radical Management.

Here are the five principles:

  • A shift in goal from making money for shareholders to delighting customers through continuous innovation.
  • A shift in the role of managers from controlling individuals to enabling self-organizing teams.
  • A shift in the way work is coordinated from bureaucracy to dynamic linking.
  • A shift in values from a preoccupation with efficiency to a broader set of values that will foster continuous innovation.
  • A shift in communications from top-down commands to horizontal communications.

I recommend the book.

Is release planning worth it?

In a word: Yes, if done professionally.

How is release planning, and release plan refactoring…how are they useful?

A few ideas:

  • It enables the Team to share ideas
  • It allows the Team to see the same elephant
  • It enables knowledge creation
  • It enables cost, benefit, time trade-offs to become apparent
  • It enables everyone to start to distinguish minor decisions from major decisions

Any professional also knows that planning is not and never will be perfect. So, we must put a reasonable time box on doing the planning.

It is also useful to plan with good ‘agile’ people. Meaning people who will use the information developed from planning in a useful way (eg, will not do the ‘stupid waterfall manager trick’ of expecting the Team to always hit the date they planned on Day Zero).

Let’s talk about this last one (minor versus major)…

To put things simplistically, there are two types of decisions, which I will call minor and major.  Minor decisions has a minor cost if we make them incorrectly.  If we are clever, we soon learn that we are wrong, and we correct the decision.

But some decisions are major. To change the decision later, it can be very costly in terms of money or time or reputation or some other factor.  Once we identify a major decision, we want to do our best to decide it correctly.  This means first being sure we have framed the decision question correctly.  Then, assuming this is a difficult decision, we want to make the decision at the ‘last responsible moment’.

***

Can planning be useless or worse?

Well, of course.  If you have people who will not learn.  If you have people who will take longer than the current knowledge can justify.  If you too many people who want to use the information for ‘stupid waterfall tricks’.

But if done with good people, using useful concepts, the Scrum Team (and others) can learn a lot doing Release Planning, followed by Release Plan Refactoring every sprint.

It is also true that we can learn by doing ‘real work’.  This is not to say ‘do only real work’…but one balances and shortens release planning (release plan refactoring) in the knowledge that we can and will learn some things faster by doing real work.

Refactoring the release plan

At the end of the last post, we had complete the initial release plan.
What were the key outcomes?

[This is one in a series of posts about release planning. See here.]

Well, the plan had some sort of scope, date and budget. Usually on Day zero the quality is ‘crappy’ to use the technical term. As it must be, given how much we don’t know on Day zero.

The real win was that we now have ‘everyone’ on the same page, at a useful middle level of detail: what is this elephant?  What are we about to do…

And then we start the first sprint.  Or more specifically, we start the first Sprint Planning Meeting.

But that is not really the end of release planning. But the beginning of RPR (release plan refactoring).

It is absolutely fundamental to agile release planning that we refactor the release plan frequently. I say (and many others that I greatly respect say) that we must refactor the release plan every sprint. Every sprint.  Ok, maybe during every 10th sprint there will be so little change, that we don’t have to change the release plan at all.  Ok, maybe this very occasionally happens. But at least we must evaluate that that is the case.

Now, when I say release plan refactoring, I mean all of the following:

* changing the vision (all of these are ‘if needed’)
* improving the product backlog items (more, fewer, smaller, better)
* re-evaluating business value (very key and very hard)
* Re-estimating the effort (eg, where Story Points are wrong, for new stories, for newly sliced stories, etc.)
* taking a new look at the benefit-cost ratios
* including new learning about risks, dependencies, learning, MMFS, etc.
* re-ordering the work
* doing a new scope-date trade-off.  Usually to make the initial release smaller (fewer aggregate story points — is one way of expressing it).
* including the newest velocity expectations (based on recent trends).
* adjusting the buffers and communicating the new, new release plan (scope, date, budget) to the right people

Now, I also include in Release Plan Refactoring all the changes to the Product Backlog information to make it ready for the Team to be successful in doing the Sprint work.  Some people use phrases such as ‘product backlog grooming’ for this. (Note: I think ‘product backlog grooming’ can have other meanings too, depending on who is using the phrase.)

These activities include:
* breaking down stories or epics into small sprint-sized stories.
* improving the stories or PBIs (wording, INVEST criteria, etc.)
* estimating the business value of the smaller stories
* estimating the effort of the smaller stories
* answering questions from the Team about the expected sprint stories
* adding detail (notes, acceptance criteria, etc.)
* adding an agile spec for each PBI to be in the next sprint.  [Sometimes this may be done 2 sprints or more ahead. But not 'way' ahead.]
* checking that the Team thinks each story (likely to go in the next sprint) is ‘ready’ before the Sprint Planning Meeting

One could argue that release plan refactoring and product backlog grooming are completely different.  I think this way of thinking is unhelpful.  One of the purposes of release planning is to make the work in the sprints more successful. Release planning is not completed until, for each sprint planning meeting, we have ‘the stuff’ ready for a successful sprint planning meeting. Among the key success criteria of that meeting is: we used the time of the business stakeholders well.

Let me pause.

Why is using the time of the business stakeholders important?

Well, they are the key independent check on the thinking of the Product Owner.  We know from long experience in our industry that ‘knowing what the customer wants’ is extremely hard. Extremely. The business stakeholders are people whose time is scarce and yet these people are essential to us in getting a much better fix on what the customer really wants (or what the firm wants).  We want them in the Sprint Planning Meeting, agreeing with what the Team takes in and, at the Sprint Review, giving us feedback.  Because these independent input and output checks are so vital, we must use their time efficiently.

Thus, for me it is better to think of higher level release plan refactoring and lower level release plan refactoring. And when people say ‘product backlog grooming’ they often mean lower level release plan refactoring of those stories about to go into the next sprint.

Again, the key idea here is that we ALWAYS refactor the release plan every sprint.  We improve it.  This is absolutely key to adaptive planning.

Dr. Royce and Waterfall

In 1970, Dr. Winston Royce wrote the paper on Waterfall.  And defined it.

Here is the paper: http://agileconsortium.pbworks.com/w/page/52184647/Royce%20Defining%20Waterfall

He identified 5 things that must be added to reduce most of the risks of doing waterfall.  And I will comment on how Scrum addresses these.


1. Program Design Comes First 

Well, I think he may have been mostly right then.  But I would rather say that ‘solution design’ comes first. Meaning that we most truly try to understand the customer’s real problem (not what he says it is) and try to design a full solution to that problem.  Not just, for example, software, but the full solution. And, assuming the product is software, then we understand better where our product plays in the fuller solution.

Scrum does not address this issue directly.  Implicitly Scrum is saying “it is hard to know whether your product will be good. So, build incrementally and try to enhance your feedback, to prove to yourself that the product will promote the solution.”

Let me add this: Some people who are doing ‘cowboy agile’ in fact do not do enough up-front thinking.  In my experience.  Yes, it is fair to say that we learn more from working software than by just ‘thinking’.  But some still don’t ‘look before the leap’.  But this is a hard thing to discuss in the abstract.  Because how much to think up-front will vary depending on many details in your specific situation (for example, the professional instincts of the implementer).

I have also seen Scrum teams get into analysis paralysis, where they are thinking still too much up-front.  In my experience, it is well worth the team’s time to discuss continually “well, how much should we think up-front about this piece?”  And they will get better at making intuitive judgments about this that are appropriate for their specific work.

2. Document the Design

Agile and Scrum do not have Dr. Royce’s level of confidence in documentation.

And Agile and Scrum see or assume a greater urgency to meet ‘time to market’ demands. Typically a high focus on documentation leads to long analysis paralysis periods.

Agile and Scrum do agree that knowledge must be shared. But rather than share knowledge mainly through documentation, the community now suggests doing it many other ways. Here are two: (1) incrementally built working product (2) lightly documented automated tests (where at all possible).  Agile and Scrum people tend to prefer cards (middle-level summaries), white boards, large sheets with drawings in team rooms, etc.

So, information is hopefully shared more, and the sharing is actually better.

Speaking for myself, I do agree with Dr Royce’s statement that many implementers tend not to want to write even basic documentation.  And I agree with his statement that much of the purpose of documentation is for use by people later.  So, those needs must be carefully considered and addressed.

This all results, if done professionally in two things:
1. We write much less documentation than at least I used to when doing ‘waterfall’.
2. We ask many people in the Team to write more documentation (in a wiki or somewhere) than they want to write.

3. Do It Twice

Yes, Dr. Royce said “build it once, throw it away, and then build the real thing”.  And his son later complained that no one really did this, so no one was really doing waterfall the right way…

The basic problem is that we are always learning, even in the last stages of the work. And that learning needs to be fed back into the final product. This was hos recommendation for doing that in waterfall.  No wonderful the waterfall products are seldom what the customers really need now.

Scrum solves this differently, by continually refactoring the current product to align with the latest knowledge.  And doing this in the ‘working product’ every sprint.

This means, yes, Virginia, there is ‘re-work.’  And the Team should be always asking: ‘How could we have avoided some of this re-work?’  And sometimes they will come upon ideas to get better next time.

This is not suggesting or expecting to arrive at a state of ‘perfect knowledge up-front’.  This will never happen. But we can learn to consider some things before we leap. Example: Is our design for this story consistent with the rest of the design and also appropriate for our complete and current understanding of what the overall solution needs?

4. Plan, Control, and Monitor Testing

Dr. Royce has some good ideas about testing.  Some of them have been superseded and some new things have come onto the scene as well.

The key thing to say, though, is that Scrum agrees so much with the importance of testing, that Scrum said: let’s do it from the very beginning (well, at least from the first Sprint).  In part, to tighten the feedback loop and to reduce the cost of implementing the changes we get from the feedback.

5. Involve the Customer

Yes!  Very important.  Again, Scrum considers this such an important idea that we do it in the form of the Product Owner, who is an essential daily part of Scrum.  In my opinion, the PO role should involve the customer in a much more practical and useful way that the ideas that Dr. Royce proposes for waterfall.

***

Much more to say, but let me keep this post short.

Early in the paper Dr. Royce says: “I believe in this concept [waterfall], but the implementation described above is risky and invites failure.”  I don’t know, but I think he meant “Compared to cowboy coding [no process], waterfall, with the 5 ‘additions’ that I will propose, seems a lot better.”

Now let me quote Dr. Royce’s last lines about waterfall:

“[This] summarizes the five steps that I feel necessary to transform a risky development process
into one that will provide the desired product. I would emphasize that each item costs some additional sum
of money. If the relatively simpler process without the five complexities described here would work
successfully, then of course the additional money is not well spent. In my experience, however, the simpler
method has never worked on large software development efforts and the costs to recover far exceeded those
required to finance the five-step process listed.” 
[emphasis added]

Are managers evil?

First, many have said that there are a lot of bad managers in the US, and in the world.

Peter Drucker worked on this.
W. Edwards Deming had his ideas, and worked on this.

And many many business gurus have had their say, trying to improve the managers.

On the other hand, there is in the agile community a bunch of people who feel that managers are evil.

OK, maybe that is an exaggeration, most of them do not think all managers are evil.  But in general, they feel that most managers are evil.

We think that virtually all managers are not evil.

Equally, it is less than useless to think of the workers as bad or lazy. Or evil.

But let us stay with the managers today.

Yes, there are many managers who do not manage well. And some may even manage in a negative or bad way.  But I think the main reason is that they have been badly taught.  No one has taught them or they were wrongly taught. Or they have wrongly learned.  For example, that it is useful to be a command-and-control manager. And we have tempted them with ego rewards, and many have succumbed.

There is, for some of them, and for some of “us”, the notion that no one can correct a manager. At least no one who reports to that manager.  This also is an un-helpful notion.

So, to replace this notion, we offer a few suggestions:
* managing people is very hard, and probably requires different skills depending on the situation and the people involved
* hierarchy and power are probably not that helpful. At least in most situations where you have knowledge workers.
* with knowledge work, knowledge creation and motivation are quite important. Perhaps yet another reason to look for a different kind of manager than we used to have.
* we speak of leadership, and some say that we need no managers, only leaders. Certainly leaders who lead us in the right direction and do it well are rare.  And we need more of them; more Steve Jobs we might say.  But I think we still need managers.

We are in the process of changing the management culture throughout the world. This will be a long conversation. There are so many dimensions. We need to talk and fight and argue about how to manage better. And, if we over-simplify things into managers and workers, the workers are very much part of this fight.

But calling one side ‘evil’ is not helpful.

Agile Portfolio Management – 2

OK, so we got started earlier.

What next?

Ummm. One of the goals of Agile Portfolio Management is making sure the most important things are done first. And that all of us are only working on the highest priority things.

One of the goals of Agile Portfolio Management is to enable us to harness change for our competitive advantage.

[Note: Agile Portfolio Management is distinct from Scrum, but I will talk about APM in a Scrum context. In a different context, one would need to explain it differently.]

OK. So how do we do that?

Well, if we have a bunch of teams, let’s say 5 Scrum teams of about 7 people each, we name a Chief Product Owner for that whole group. The CPO prioritizes a high level Product Backlog, and assures that all 5 teams are only working on the most important stuff. The CPO must organize the “Product Owner team” so that great “stories” are given to each team. So that lots of Business Value is realized in every release, much more than before.

The CPO is not trying to make individual teams efficient per se, but trying to identify and get the Business Value released (and get the cha-ching, the dollars rolling).

The CPO (and the PO team) is always surveying the winds of change, to enable our company to adapt faster (or to minimize bad impact).

Every month, the PO team is looking at all efforts and teams, and asking: How can we adapt faster so that more BV is realized? They recognize all the different learning that is going on, and see where it leads them. The monthly cycle is largely because this is the typical frequency with which senior stakeholders can engage and participate. So, the PO team is looking across all the teams and saying: Ok, where is the best place to invest now?

Many consequences could arise from these conversations:
* any month a significant effort could be decommissioned
* any month a new effort could be started
* the direction of any team could be changed, perhaps in a minor way, perhaps in a more major way
* the master Product Backlog is refactored with input from all stakeholders
* stories are eliminated, modified, added…and the impact of this is understood and socialized

Thus, at a fairly high level, the overall direction of this group is adjusted. Then, at a lower level, the CPO gives specific stories (maybe larger ones) to each Team. The PO for each team typically will need to organize the refactoring of the (large) stories into smaller ones that can go into an individual Sprint for his Team.

The PO team does not attempt to micro-manage at a level below the Story. And in general, the PO Team does not have time to deal much with small stories, unless there is conflict or important learning needed about such things as: “how does this story fit with our overall direction?” “how does the story in team X fit with another story in team Y?”

More later…

Agile Portfolio Management – 1

A few people have been asking about “Agile Portfolio Management”. Or at least about “how do we manage this stuff?” and what they mean is what I call Agile Portfolio Management.

Agile Portfolio Management is of course distinct from Scrum, but for simplicity, I have assumed a Scrum context.

First, Scrum is relatively silent on this subject, which is well and good. It is an advanced subject. And one can’t implement “all” of Agile in a single go. So, better to make it an advanced topic.

Still, I have heard others say that if one gets “demand management” down (controlled) in an Agile way, then all the Team stuff (eg, all the other Scrum stuff) becomes so much easier to implement.

One might say: Mura, muri, muda. That is to say:
* Establish an evenness of flow first
* Do not overstress the system
* Then remove waste (or, one might say, other wastes)

Let’s unpack these for a moment.

You can’t get evenness of flow if the team is constantly being interrupted (for example). So, demand management means you have to control the flow of demand (new features) into the team to eliminate interruptions (and allow change).

You have to get business (and the team) willing to identify each team’s capacity and NOT over-stress the team by asking them to deliver more than their capacity. When you over-stress, you actually reduce the real capacity of the team.

Then, removing waste, in simple terms, is removing the impediments identified by Scrum.

Next, some discussion of “single product backlog” (for multiple teams) and “chief product owner”.

Note: Apologies for typos in the earlier version.