Software development is like golf in that your chosen path to the pin is a primary problem.

The choice involves weighing your capabilities (people), the course (technology), and the conditions (market).

Confident you can do anything?  Bring out the big guns and send it over that treeline on the left. If you make it, you must land it among that sea of traps. This is the most common choice in software development, and the #1 reason why we so frequently turn “par 5″s into 10, 15, and 20s.

Don’t have a team of Tigers?  Then go long down the center if you can avoid that large sand trip on the left and lake beyond it. But is this abstract little map accurate enough?  Does it tell us about the 50 yards of soggy turf there in the middle?  How about wind howling left to right over the lake?  Unless you’ve played this hole before you don’t know.  What makes software development so tricky is by definition we never play the same hole twice.  Technology is changing around us, even while we make our own changes.

Want to make sure you don’t turn a par 5 into a 10?  Land it short of the traps on the fairway and take it from there with comfortable strokes. There’s a price to pay for this caution: no holes in one for you.  You’re less likely to be a hero this way, but in team-scale software development, the hero model will fail you are sure as a week in Vegas, anyway.

And, sometimes, the conditions are particularly bad.  In the downturn of 2008/2009, one could say the conditions for technology products are analogous to “a raging hurricane, with chance of nearby volcanic eruption and ash over the course.”  So take care. Be humble.  And may you keep both your work in progress and your golf scores down.

(apologies to all software developers offended by an anology from the “sport of salespeople and CEOs”.  Think of it as an analogy to bridge the divide)

A universal challenge for technology companies is having more demands to improve the product than we can implement.  This problem gets bigger as we get more successful.

Because our capabilities and those demands shift over time — if we want to maximize the value of what we deliver to the customer, then we want to tackle things in a prioritized fashion, knowing we simply won’t get to it all in any one release cycle.

And this prioritized breakdown better supports moving to a lean/ kanban workflow.

How to best analyze and prioritize all these requests, then? We want to be able to do it systematically, regularly, and have these priorities reflect (the best we can) the sweet spot of both the market value of an idea, and the engineering cost to create it¹.

This last part is difficult, but especially important.

Say we have a few alternative design ideas for satisfying a need. Because it may appear “anything is possible” in software, we may be tempted to try to deliver exactly “what the customer wants.” Let’s say that’s design A.  Unfortunately, developing design A could be a bad choice, because it could easily take many times the effort of a very similar and nearly as appealing choice B, just because it asks for some functionality that doesn’t neatly fit into our existing system and available components around us.  A fundamental principle of software engineering is that even a small shift in requirements can cause a huge shift in cost and/or risk of development.

It’s similar to choosing to fit within the limitations of available off-the-shelf parts for a home remodel — it is obviously much cheaper than buying custom.

But “off the shelf” is an unfortunately non-obvious, slippery concept in the shifting world of software.  To reuse something, whether it’s your own code or someone else’s, there’s often a chain of “if”s you have to walk down: “We can save 2 months of effort by using this nice library IF we assume customers want Windows .NET only; IF we use C#; IF we take a dependency on .NET Framework 3.5 SP1 to get the libraries we need; IF we only do features A, B, D, and E, and punt on C, because it would require we rewrite and replace the library…” and every such path is usually followed by a “BUT, if we do that, then we are locked into not doing …”.

In most cases, developers on your projects won’t know all the alternatives and consequences until they’ve delved deeply into the design and usually into the code.

This is one of many reasons why two strategies are so important in getting (re)prioritization right for software engineering:

1. Include both marketing and engineering equally in the decisions of what features to prioritize.  Systemically account for both world views, while coming to one decision.
2. Plan to adjust your feature set over the course of the project, as your team learns new things.  By allowing for small adjustments and sacrifices in the requirements, you can dramatically lower the project cost and risk.

#2 is common advice for a host of reasons.  #1 can be achieved with the right people, and a structured decision making method like perpetual multivoting, or a Delphi decision making method that will be described in a future post.

When the right people are paired with the right process in this way, the spigot of innovation will open wider, benefiting both you and your customers.

Notes

(1) We actually want the sweet spot of the triumverate of Voice of the Customer (VOC),  Voice of Technology (VOT), and Voice of the Business (VOB) — so we can prioritze the work that will deliver the most value to our customer, with the lowest effort and risk, with the best financial outcome for our company.  In many companies, we break these perspecives down (for better or worse) into specializations: sales represents the pure VOC, marketing VOB, and engineering VOT.  So the challenge is — finding a sweet spot means getting perspectives from several people, often with very different backgrounds and communication styles, who wouldn’t normally be caught dead getting drinks at the same pub with each other …

Frequent releases, which are central to both agile and lean methods, sometimes draw a visceral reaction because people fear we can’t keep the product that close to release quality at all times, while still delivering as much innovation.

That is a real challenge of agile/lean methods. But making this argument against short cycles is difficult, so the most common argument ends up being “the customer doesn’t want a release every month (or every 6 months, or every year …) anyway.”

Unfortunately on any project with many customers, while no customer wants a release every month, there is always one wanting a release right now.

We can deal with that to some extent by having tiers of releases: the single-customer quick fix, the multi-customer patch, the service release, and maybe minor and major releases. But each of these tiers involves extraordinary cost and waste from duplicate efforts — waste that can often be avoided if the main release cycle is short enough that customers can get their needs met.

It’s better to embrace the challenge and compelling benefits of feedback on short cycles. Here’s a rough diagram of a typical three-tier set of daily, weekly, and monthly release cycles.

The heart of it is a per-change or, at worst, a daily build (continuous integration). This build is picked up only by people who are in close contact with the project. This discipline keeps everyone in sync, and keeps the project from wandering into a broken state.

The weekly build (or some equivalent) is important whether at a large organization (where many remote teams share dependencies) or at a smaller startup (where the salespeople and management interact with the product daily). Tightening up the feedback loop of these internal customer proxies creates transparency, builds trust, and keeps the product from evolving off-track feature-wise.

Releasing something to customers every month can seem daunting in some large organizations. The biggest of the software beasts (Microsoft) has had challenges but also great benefits in doing so. And if you think you have a great plan set in stone (a very detailed set of requirements), all the feedback these releases will generate would seem to be just a source of endless distraction.

Don’t be foolish. Unless you’re delivering a 1-1 functional replacement for some existing product (and how often do we do that?), you desperately need that feedback. It keeps the team connected with the customer, motivated by the customer, doing right by the customer. Concerned about opening your kimono to competitors? Limit your audience to a trusted subset, like Apple’s AppleSeed program and most others do.

Once the team gets used to a cadence of regular releases, the practice becomes the heartbeat of the organization, keeping everyone on track, in touch with reality, and constantly learning.

When cycles get shorter and our teams become more empowered to react to change, one fear is that accountability will get lost in all those changes.

Specifically, when something goes wrong, what is the root cause? Are my people failing? our processes failing? our plans unrealistic? How can management learn how to head off these failures in the future, if we aren’t making commitments and measuring progress against them?

Step one is to take some of this pressure off — in fact, to embrace failure as a path to learning, and taking a statistical approach to making the most of it.

Like a pharmaceutical firm screening new compounds, or venture capitalist building a portfolio of investments — a manager in a high-risk domain needs strategies to spread the bets to maximize opportunity while minimizing overall risk. This is basically Set-Based Design (Toyota’s Set-Based Concurrent Engineering).

Software development, in particular, is a research and development activity suited more to this approach, and much less of a traditional production activity.

Step two is creating an environment with much more transparency — it’s not about trusting people to execute to plan, rather it’s about trusting people to be transparent about the true progress and status of the project, so that everyone can adjust accordingly.

One mechanism is a public kanban board like the kind Corey has been exploring on this blog (from work with David Anderson at Corbis). By watching the board over time, throughput of the team and bottlenecks within the team become clear.

An electronic version is important if there are people (dependent teams, remote teams, or upper management) that can’t huddle around the board.

A Cumulative Flow Diagram is an electronic alternative that can be a great way to both summarize the flow of value, gain visibility into the history, and see important management events (like estimation troubles, or WIP getting out of hand, or new priorities causing the plan to grow out of control). This CFD is again from David Anderson, as described in his 2004 BorCon presentation.

In a future post, we’ll look at a way to create and manage by CFDs, even when each kanban (or feature) is not similarly sized — this involves also collecting time data (which then has other uses).

And, of course, if rework and bugs are tracked separately (as they usually are today), then traditional bug charts are critical to management.

Should a small team of 4-6 developers with a strong process like Extreme Programming layer this kind of data collection on to their process? Probably not. But as teams grow to 15, 50, or beyond — this kind of transparency is critical glue to keep management and teams coordinated, even while allowing each individual and each small group to work on short cycles and be highly responsive to change.

On your projects, have you seen other forms of data collection that are both lightweight, keep everyone in touch with reality, and help build trust?

Here’s some of why people say that long-term, full-detail plans are essential:

1. You need the detailed work breakdown structure through the end of the project to produce estimates.
2. And you need estimates to schedule handoffs, deliverables, and other dependences between teams.
3. And as things do change, you need a plan through which to communicate those changes.

How can we satisfy these needs while still allowing small teams latitude to adapt and be agile?

Concern #1 is a red herring of sorts. Estimates constructed from a detailed WBS are not the most accurate, if you’re in a domain with significant unknowns (like most new product development). In these domains, you’ll get much better estimates from other methods like an experienced expert or group of experts using a technique like Wideband Delphi. For more, see a book like McConnell’s Software Estimation: Demystifying the Black Art

#2 is a dominant concern for organizations with long internal lead times. The motivation and techniques for attacking this problem in other ways is what lean thinking is all about. In short, agile/lean teams are much better equipped to handle changes in other teams’ plans, so they don’t need those plans to be as firm. It’s a self-reinforcing benefit of shorter cycles that pays off in spades.  The trick is keeping the peace during the (often long) transition period where an organization has a mix of long-cycle and short-cycle teams. These solutions to #3 can help during this transition.

Concern #3 speaks to allowing your high and low level plans to evolve as you progress and learn. But how do you keep them in sync?

• Have top-down goals and priorities that are clear about the customer and business need, but that don’t over-anticipate the technology to best fulfill that need.
• Be prepared to take top-down input and provide bottom-up feedback as part of your regular planning cycle (e.g. Scrum’s monthly sprint planning).
  • For inputs, the Scrum Product Backlog and processes around it are an effective way to turn top-down priorities into actionable technical workitems.
  • For feedback, provide actuals. In order to keep the trust of the organization, some kind of actuals in terms of feature throughput, earned value, or time data, etc. are essential. If agile teams “go dark” on a large organization, it becomes harder maintain trust when things go bad (as they invariably will from time to time on a large project).
  • For feedback, provide new estimates on the larger goals, based on this last cycle’s progress on specific workitems. To make this feasible, use a fast group estimation method like planning poker or its elder kin, wideband delphi.
• As the size of the team goes up and dependencies between teams get more tangled, coordination on just a monthly basis isn’t enough. Getting information more frequently than your usual planning cycle (or getting your planning cycle down to one or two week sprints) may become essential. The diagram above says weekly (which might match an org with more than 6-8 Scrum teams).

  This might also be the threshold where project management specialists are called for — don’t distract your project leads with sub-sprint communication and coordination between teams. But also don’t lose Scrum’s designed benefit of protecting teams from constant interrupts — the team controls whether their plan changes within a sprint. Project Managers can help make sure status and communication flow between teams even during a sprint, but they (like all stakeholders) should be prepared to hold new work and priority changes until teams plan their next sprint.

If you’re adopting short-cycle methods in a (long-cycle) large organization — what are your pain points that weren’t covered here. And how have you adapted?

One of the most common, valid critiques of agile or lean processes is the time horizon of planning. Scrum focuses on one month sprints. XP advises shorter iterations (2 week, typical). Lean focuses on a single piece (one feature, in the case of design projects), delivered in the shortest possible time.

To many organizations and many people — especially when they first manage projects — these kinds of planning horizons are crazy and negligent. Rather, they strive to plan in as much detail as possible, out to the end of the project. They want to identify critical paths, plan resources, etc. It’s obvious, right? Ah, but I see you’re smiling.

Unfortunately, what you may know (but isn’t obvious to everyone) is this over-planning can be disastrous when there is any level of risk or significant unknowns. Almost any non-trivial software development project would fall in this category.

Usually, this highly detailed initial plan falls quickly out of touch with reality, and must be ignored by the team after a certain point. Good project managers will try to adapt the plan, but if they built in too much detail initially, they’ll find keeping it up to date impossible. Either way, this all can be damaging, as now the team often feels like they’re confused and failing, and management or stakeholders can quickly get dangerously out of touch — they’re still looking at and expecting that initial plan.

Beyond that, there are a host of other harms. First among them that you’re trying hard to lock down your plan at the earliest possible stage of the project, when you have the least understanding of what customers want, what the technology is capable of, and how quickly your team will be able to deliver it. You’ve not explored or mitigated any of the risks yet. You’ve basically committed to be as unresponsive as possible to the new things you learn as the project unfolds.

This is such a common problem — so much pain and so many failed projects could be avoided if it could be solved. And a simple conceptual solution is widely known, but is under-adopted.

It’s called Rolling Wave Planning. And it’s one effective way to unify the worlds of agile/lean and traditional project planning. Here’s a crude diagram illustrating how plans are detailed in the short term, but get progressively more generalized and flexible in the longer term.

How does this work?

• Identify just a few strategic, long-term product line and product goals. If they don’t fit on one side of one sheet of paper, they’re probably too long. These might look 1-2 years out for a large organization.
• Expand that into a short, prioritized list of near-term problems for your team to solve in the coming year.
• Bring in your more technical people to produce a short list of functionality the organization is capable of delivering in the coming months to make progress towards solving those problems. There should be lots of room to scale bells and whistles up or back, and especially to make technical choices about how to implement the functionality — you will reap significant efficiencies if your team can adjust as they learn more about the technologies involved and how long things will take to implement.
• Involve the whole team to do a detailed work-item level just a few weeks ahead. If you have a low-risk, well-understood domain, you could choose to approach this as a work breakdown structure with gantt chart and analysis. If you’re in a higher-risk domain (like new product development), use Scrum-style monthly sprints or, even better, a lean production flow. This is the schedule people can rally around for day to day work.
• At the end of that shortest planning cycle, percolate your learnings from the small, granular work through to the larger grained goals, then back into your next short-term planning cycle. The key to making this doable is again to not allow too much detail into the larger goals. Keep them high-level, meaningful, and always flexible.

In short, you match the level of detail to (1) how far out in time you’re planning and (2) how risky your domain is.

By doing so, you’ll gain a host of benefits, many of which relate to lean — reducing work in progress, making decisions at the last responsible moment (when you have the most information), pushing responsibility down and empowering the people who are closest to the problem, and generally being open to feedback and agile in response to the changing forces around your project.

Lean thinking is one of the best starting points we have to systematically attack this problem with savvy about continuous improvement, shifting bottlenecks, systems thinking, statistical management, and respect for people on the front lines of the problem. And it’s been under-applied in getting us past the breakdown of traditional project management techniques in high-risk domains like software development.

But successful lean companies like Toyota have taken years or decades to build up institutional and cultural knowledge of where to start and how to evolve. Can we shorten this learning process for other companies or other domains?

Our unique circumstances and the changes around us require a kind of dance to make progress and stay balanced — sometimes steps forward, others to the side or back. This non-linear adaptation is very jarring for both our managers and our teams.

We need to find a way to empower people with the savvy to sense dissonance between the process we have vs. the process we need, give them the vocabulary to be able to discuss it, and the power to take action on that dissonance even if the solution is a step in a new direction or even a step back.

One of the best places to start is by attacking the belief that there is “one right process” for our teams.

Instead, we drive dialog around the spectrum of possibilities between any two poles or dualities: predictive vs. iterative management, larger vs. smaller batches, top-down vs. bottom up control, standardized vs. adaptative process, specialist vs. generalist teams, etc.

It’s not about choosing one or the other .. it’s about where you are on the spectrum.

As managers, we probe our teams, asking if they should be trying “more of this” or “less of that”. We can go forward or back on a spectrum, and we can step “to the side” by focusing our energies on a different duality.

What would help — in fact, what’s almost essential — is a pattern language to give names to abstractions and make dialog and discussion about where we are and where we’re going possible. Unfortunately, the PM pattern languages you’ll find today are based on absolutes (an assumption of one right process). We’re looking for one based on dualities — opposing forces or alternatives that we must balance to achieve the best-fit process for our circumstance, for this one point in time. We want terminology that ask us to think, adapt, and step in whatever direction our circumstance calls for.

Boehm (balance) and Cockburn (meta-methodologies) are wonderful starting points for this kind of thinking, at least in software developement. I’m sure there are others — please add a comment if you want to point out a resource.

Can we discover and build this pattern language of adaptive project management — and make it a an approachable, practical tool for today’s managers and project teams?