Tool for Managing the Feature Development Process

Question

Background: we currently use MantisBT for tracking of bug tickets, and have attempted to use the same for feature development. The latter has worked, but only to a point. Ours is a small shop, so large Agile methodologies seem a bit much, and none of us are really well-versed. The software/cloud products I keep finding all share that theme: very large. We are in the process of setting up a physical Kanban board for the procedural stuff, but I need a way to track the actual feature maturation process.

Question: what tools are available for specifically tracking feature development?

As a basic example: I would like to create a "feature" and then add to it supporting details such as a description, files (pictures, files from Balsamiq, Word docs, etc.), priority, users, resources, and time frame (start/end dates). More, of course, but I hope you get the idea.

You would be correct in thinking that this seems a lot like generic project management. And if there is a tool that fits the bill, I want to consider it. The more closely it suits software feature development, however, the better.

I have found a weath of tools that might fit the bill, but the specific parts for tracking features always seem to be part of a much larger system. Are there any that focus specifically on the feature lifecycle, without trying to encompass every aspect of the agile process?

Answer 1

I rather suspect that I would approach this as "tools & techniques to construct work packages". From my limited understanding, a "feature" is nothing more than a work package - a discrete deliverable with schedule & requirements.

I don't know of any software to assist in constructing and managing work packages, but I think that @CodeGnome's law is "Build your process then automate it." I could probably generate a quick form in Microsoft Word or Access that would require me to specify for each work package:

• Name/Title
• Description
• Directory for attachments/artifacts (including files)
• Formal requirements
• Customer owner/stakeholder
• Key users
• Schedule (Planned/Projected | Start/Finish)
• Key resources
• Priority

Once I have that form and I have a process that uses that form, and satisfies my stakeholders, I'd then look at automating the process.

Or, we could both get lucky and someone on PM SE will point us to software that assists in the development/management of work packages.

Answer 2

These are actually two different topics:

1. How to keep track of the description of the the required feature and its details (the request in itself)
2. How to keep track of the actual implementation work of the required feature

Regarding the first point, I have to say that there is nothing out there that can be used as is for this task (AFAIK), As you already noted, all of the existing bug/feature tracking systems have a much broader aim.

My personal suggestion is this: develop your own web application to keep track of feature requests. Using the right tool (Ruby-on-Rails, Django, Padrino, etc.) this can be done in quite a short time and with a reasonable effort. You could also extend/modify Mantis or Bugzilla to fit your need.

Another possiblility is to use a normal Project Management program (Like Gnome Planner) to keep track of the details of the request and its progress. Unfortunately, such a tool must be kept up-to-date by hand so you can be mathematically sure it will became obsolete in a week or two.

Regarding the implementation work tracking, the approach that I see most often is the typical Continuous-Integration one based on tests (TDD). Every feature request is associated to a set of tests (JUnit or something like that) aimed to test the individual functionalities of the new feature. Running the test suite at build time, you can see how much of the feature is already implemented and working. With some CI tool (or with some cutom-made script) the test results can be used to feed a "control panel" or a "dashboard" used to keep track of the whole development work.

Maybe Hudson and/or Jenkins can offer you what you need.

These tools can be intimidating at first and most likely are an overkill for you. I mention them just because is impossible to ignore them.

The CI approach is not always appicable (mainly for environment-related reasons). In these cases, sometime it is possible to rely on the //TODO: comments. Just ask your developers to put a //TODO: comment in their source files for any not-yet-implemented functionality requested by the new feature and keep track of how many of these tags are disappearing to get an idea of the implementation progress. Unfortunately, you will need some kind of custom-made script to extract this information from the source code and publish it to your control panel.

A tool that can give you some inspiration is Hackystat. Hackystat is interesting because it is automatic but has a couple of very serious limits:

1. It tracks almost everything. Most likely it is too much for you.
2. It really tracks everything. Most likely it would make your developer furious about their privacy...
3. The hackystat plugin exists only for Eclipse AFAIK. If you use another IDE, you cannot use it.

Anyway, there are many commercial tools similar to (or even better than) hackystat out there.