Feature Driven Development

Feature-driven design (FDD) is an iterative and incremental software development process that follows the principles of the agile manifesto. The idea is to develop the high-level features, scope and domain object model and then use that to plan, design, develop and test the specific requirements and tasks based on the overarching feature that they belong to.

There are five basic stages in the FDD approach as illustrated below:

The first two phases establish the overall model (including prioritized feature list) and occur upfront. The subsequent three phases happen iteratively for each feature. The next section discusses each of these five phases in turn.

Develop Overall Model

Using techniques similar to performing a formal functional analysis, you need to first define the overall mission, scope and business objectives of the system being developed. You then create business domain models of the system, starting with individual components or sub-systems and then consolidated into a complete model:

You can divide up the models by team, functional area, or sub-system. The modes will be used to guide and direct the next phase – building the feature lists.

Build Feature List

Knowledge gathered during the initial modeling is used to identify a list of features by functionally decomposing the domain model into subject areas.

Subject areas each contain feature groups, which are then in turn broken down into a discrete list of prioritized features. Features in this methodology are considered small pieces of client-valued functionality expressed in the form "<action> <result> <object>", for example: 'Calculate the total of a sale' or 'Validate the password of a user'. Features should generally not take more than two weeks to complete, otherwise they should be broken down into smaller sub-features.

Plan by Feature

Once you have the list of features in place, the team will need to prioritize them and assign them to a specific two-week time boxed scope of work called an iteration. To simplify planning, it may make sense to plan an entire feature group for a specific iteration.

In either case, once you have defined the requirements for an iteration, you will then need to assign the development and testing activities for that iteration by feature.

Design by Feature

A design package is produced for each feature in the iteration. Together with the corresponding domain model area owners, the system architect works out detailed sequence diagrams for each feature and refines the overall model.

Next, the class and method signatures are written and finally a design review is held.

Build by Feature

After a successful design review for each activity to produce a feature is planned, the module owners develop code for their module.

After unit testing and successful code review, the completed feature is promoted to the main build.

Benefits / Drawbacks

To see how requirements can be organized by functional area, they must be fairly well understood and so a design is created. From the design is derived a feature list at which point the iterative implementation cycles can begin. Consequently, and as with some other methods, the first two phases of the FDD process are not iterative but take place just once which narrows the iterative part of the project, and so it could be argued that the agility of the overall project is reduced.

At the same time there are some real benefits to this approach. For example, with each functional area written all at once there is less need to refactor than with a process where the same code might be repeatedly changed. Not surprisingly, less refactoring is one of the benefits of traditional development methods so in some sense FDD can be argued to combine both traditional and Agile approaches.

What Makes SpiraTeam the Best Choice for FDD Projects

When your company requires better software planning tools, there are a lot of choices in the marketplace. However, if you want the best in agile software development with there is only one solution.

SpiraTeam® is a complete software project management system in one package, that manages your project's requirements, releases, iterations, tasks and bugs/issues. Designed specifically to support agile methodologies such as FDD, Scrum, Extreme Programming (XP), DSDM and Agile Unified Process (AUP) it allows teams to manage all their information in one environment.

SpiraTeam	Extreme Programming	Scrum	FDD
Epic	Epic	Epic	Feature Group
Requirement	User Story	Backlog Item	Requirement
Task	Task	Task	Task
Release	Release	Release	Release
Sprint	Iteration	Sprint	Iteration

SpiraTeam® provides reporting dashboards of key project quality and progress indicators - requirements test coverage, task progress, project velocity, as well as top risk and issues – in one consolidated view that is tailor-made for agile software development methodologies as well as supporting your legacy/hybrid waterfall projects. The top reasons that our customers choose SpiraTeam® over other solutions are:

It is a complete solution that includes requirements management, release planning, iteration planning, task estimation and defect tracking all fully integrated from day one.

Highly intuitive web application that provides a complete picture of a project’s status and health yet requires only a web-browser.

Methodology Agnostic – SpiraTeam® can be used equally web for any agile software development methodology – including Scrum, AUP, XP, DSDM

Ability to leverage your existing technology investments. SpiraTeam® integrates with many third-party defect-management systems and software configuration management (SCM) systems.

In addition, we provide superb technical support that ensures that enquiries and questions are dealt with in a timely and professional manner.