Home > Articles > Software Development & Management > Management: Lifecycle, Project, Team

  • Print
  • + Share This
This chapter is from the book

2.4 Recognizing a Bad Plan

We have been discussing the reality that the cornerstone documents of project planning—the Vision Document and Functional Specification—often fail to produce the benefits that one might hope to gain, relative to the cost incurred.

By recognizing the typical planning problems that plague projects, you can better redirect those projects and more readily avoid those mistakes in your own planning. And there is no lack of bad plans out there to be found. It is easy to recognize bad plans by looking for some telltale indicators.

Underplanning

First, look for signs of underplanning. If the plan is sparse, it may mean that the plan suffers from a lack of good planning. But that is not necessarily so. The best plans should be the most concise. You can't confirm underplanning based on small size alone. You must look for the absence of critical components such as a Data Dictionary11 and a blueprint.

Overplanning

Overplanning is more reliably linked to large size. If the plan is bulky relative to the scope of the project, then it may suffer from too much bad planning. Bad plans tend to make up for their lack of quality with sheer volume. The key concern should be quality, not size, and conciseness is a key metric of quality. Don't be fooled by size!

Lack of a Data Dictionary

Perhaps the most glaring sign of a bad plan is the lack of a Data Dictionary. Without an unambiguous vocabulary, the language of the plan is almost certainly imprecise and inconsistent. This ambiguity will inevitably lead to programming questions or errors due to imprecision in what was felt to be perfectly clear and detailed narratives.

Metadata

Another symptom of overplanning is a predominance of metadata.12 Metadata is information obtained during the analysis of the client business processes. It includes things like Use Cases, Test Cases, Sequence Diagrams, Process Flow Diagrams, narratives, and other analytical graphics. Metadata may be useful in understanding the business requirements, but not necessarily useful in communicating requirements to the development team. Planners that call it a day after producing metadata alone seldom deliver a useful blueprint.

Unless someone sifts through metadata to find its bearing on software requirements, it remains a nebulous fog, which can obstruct the vision of the developer. Information in blueprint form should not need to be further analyzed by the developer in order to establish its relationship to other elements or to the functionality to be implemented.

Extraneous Detail

Another telltale sign of a bad plan is the presence of a lot of unrelated, unorganized details. These plans contain extraneous information simply collected and tossed in, assuming that someone, somewhere, sometime, may need it. It was probably acquired in an uncontrolled information dump13 from the client, never really understood or analyzed, but included mainly to protect the planner from being blamed for omissions.

Premature Planning

Yet another sign of a bad plan is a premature or presumptuous planning schedule that violates phase integrity.14 For example, the analyst should not necessarily be the one to specify things like database structures, object models, and architectures. The purpose of the analysis phase is to determine the business need. The planner should leave structural decisions to the software architect, who will produce an implementation plan based upon the technical requirements.

If you intercept a plan prior to completion, it is very easy to see if it contains premature planning. If the plan is complete, it may be more difficult to determine whether plans were made before all the necessary data was acquired.

Appearance

Appearance can indicate poor planning. A shoddily presented plan may reflect a lack of attention to detail and quality. If there is an apparent lack of pride in the presentation, look closely for signs that it also lacks cohesiveness and sufficient attention to detail in the content.

On the other end of the spectrum, some of the worst plans are the most impressive- looking ones. They contain full-color diagrams to illustrate virtually every imaginable aspect of the project. These are the ones likely to suffer from overplanning. The planner was probably more concerned about showing off his wide array of presentation graphics then actually providing anything useful. Look for indicators of insight into development needs, not for attention grabbing frills.

Boilerplate

You can also skim the plan for boilerplate to judge quality. Boilerplate will jump out at you after you learn to recognize it. It takes the form of endless tables of cut-and-copied information, and is reflected in meaningless platitudes such as "the software shall be user friendly and easy to use..." This kind of material makes great filler and feels warm and fuzzy, but conveys no meaningful information. Would anyone ever specify software that "shall be confusing to the user and difficult to use?" This stuff is there because the plan is targeting client and internal management fluff, not substantial developer requirements.

Rigidity

Look for signs of rigidity. These plans typically suffer from a lot of detailed mock-up screens and statements such as "any deviation from the plan will require a change order submitted in triplicate to be submitted to the steering committee for approval at their monthly status review meeting after initial screening by all department managers and the client representative pending feasibility and impact analysis..." This plan is likely to produce exactly what it specifies but is unlikely to produce satisfactory results. Overly rigid management is the most common knee-jerk response to previous bad planning, but it typically exacerbates the problems it is intended to control.

Lack of Process

Another way to recognize a bad plan is to simply ask to see what formal process produced this plan and where the format of the blueprint is specified. If these things aren't available, then the specification was almost certainly produced by an ad hoc planning process. This should make you very skeptical and suspicious.

Paperpushing

Always ask what automated system was used to organize and ensure the integrity of the specification. If the team used paper and pencil, email, word processors, and even spreadsheets, chances are the specification is full of inconsistencies. I know because I have tried to organize and maintain an effective software blueprint using a word processor and a spreadsheet, and I failed miserably. It is extremely difficult to maintain a living, internally consistent software blueprint without an automated tool that integrates all aspects of data (not mere document) management.

You would be skeptical of an accounting firm that managed all your financial records with a pencil and paper, would you not? How could one imagine that a software blueprint of any complexity could be managed without software designed specifically for that specialized purpose?

Developer Driven

Ask the developers if they had helped specify, or at least had signed off on, the structure and content of the blueprint. If they did not have input, chances are that the specification does not serve their needs.

Retrospect

Unfortunately, the best way to recognize a bad plan is after it is too late. A bad plan drowns the team members in an ocean of irrelevant or inconsistent detail. It ties their hands so that they must implement inefficient or inelegant user interfaces and architectures. It forces them to make guesses or reverse engineer to try to gain the precision it lacks. It leaves the development team frustrated and confused about why they can't seem to find answers to a hundred implementation questions despite the impressive and voluminous specifications they were provided.

The Litmus Test

Here is a practical test. Take a small, well-defined section from your specification and hand it to a developer. Ask him to review it and then ask if he has any questions or issues that require clarification. Tell him that this is his last chance to ask questions before he is put to work on it.

Does the developer question anything that you thought was perfectly clear from the document? Did he ask for definition of terms or clarification of logic? Did he feel confident that the document provided all the information needed to proceed? Did he have any concerns about the specified strategy for implementing the specification?

Certainly, since we don't expect any plan to be perfect, there will be questions. But did these questions expose any issues that you thought were clearly stated or had been fully specified already in the document? Are the questions expected drill-down, or are they questions that you thought should have been clearly answered in the document?

In many cases, when developers are given the chance to provide feedback, the plan is exposed as terribly lacking. If this is the case, then perhaps your planning effort should be improved. And let's be very clear: Improving may not mean more planning. It may mean less planning but smarter planning.

After you finish this book, you will hopefully have a more critical eye when you review a project specification. Telltale signs of bad planning will jump out at you. Practice this skill. Whether you are a manager, an analyst, a planner, a developer, or a client, the ability to critically appraise specifications for true substance will be invaluable.

When you recognize a bad plan, tell the authors specifically what they need to do to make it more useful. They will hopefully be grateful for specific, constructive suggestions.

  • + Share This
  • 🔖 Save To Your Account