Abstraction

Most companies with which I’ve worked use Microsoft Word documents to manage their requirements. In my experience, the process usually goes something like this: the product manager sits down and writes a PRD over the course of some weeks (how the PM arrives at the specific features is the topic of another post) . Triumphant upon completing the onerous doc, the PM emails the completed PRD to the various stakeholders (executives and engineering, primarily), none of whom read it.

A review meeting is scheduled. If inexperienced, the product manager imagines a meeting in which people will alternatively praise the PRD and say things like “I don’t fully understand requirement number 344, can you elaborate?” The meeting, it’s imagined, will take an hour or so.

The experienced product manager girds himself for the wrenching, grating, contentious, plodding marathon that awaits. Each person in the review meeting is reading the document, projected onto the wall, for the first time. Some participants have an idea what the goals of the next generation product are, none of which align with the PM’s vision. Most participants don’t really know what’s going on. Hours later, the meeting adjourns having discussed only a few requirements.

And so it goes, meeting after meeting. Multiple revisions of the PRD are generated, each emailed about. Soon everyone has a different version. Documents that have the same version number have different content. And so on.

Okay, so a lot of things are wrong here, but I don’t have the energy to address them all in a single post. I’m talking today about doing away with multiple iterations of word documents to manage requirements. Instead, move them all onto a centralized online system. (Make sure it’s backed up regularly).

There are a few commercial systems for online requirements management, but I use trac (http://trac.edgewall.org/). It’s a open source bug tracking system similar to bugzilla or mantis, but it’s easily customized for requirements tracking. After many, many false starts with various solutions, Trac seems to best fit the bill. It isn’t perfect, but it’s pretty good. Here’s what I like about it (I use the development version, 0.11):

• You can enter requirements individually and sort them any way you wish. Want a list of the next project in order of priority? Boom. What the same list according to engineering resource required? No problem. What a list of requirements specific to an individual component in your product? One click away.
• Anyone can ask questions or make comments about requirements, and everyone can see other’s comments so there is a positive feedback loop with little redundancy.
• You can label entries any way you wish. My system has categories for requirements, requirement candidates, feature requests, change requests, and use cases.
• You can build custom fields so that requirements can be categorized as many different ways as you please. I’ve created custom fields for “estimated engineering effort,” “customer,” “project name,” and many others
• You can identify milestones, associate requirements with them, and build a roadmap with a single click.
• It has a built-in wiki. I use it wiki pages as a project home page, with links to sets of requirements and use cases.
• You can embed images into requirement listings (my team often creates flow charts illustrating use cases and embeds it in the requirement).
• You can upload any kind of attachment
• You can view all changes to a requirement made over it’s lifetime, with a chart showing the differences between one iteration and another.
• You can integrate the system with CVS, subversion, or perforce so that you can directly associate code with the requirements.

What don’t I like about it? Hm.

• There’s no WYSIWYG interface; product managers must use wiki syntax to enter requirements. This can be a problem when entering complex tables and such. Usually the team just attaches a document if necessary (or embeds HTML).
• I cant’ think of anything else.

It’s a great collaborative tool that centralizes all requirements and does away, once and for all, with the stack of paper that no one reads anyway.