HomeAgileFeature Driven Development (FDD) Explained

Feature Driven Development (FDD) Explained

What is Feature Driven Development (FDD)

Feature Driven Development (FDD) is an agile approach that categorizes software development projects around features.

In this context, features are not product features or requirements. They are, however, similar to user stories in Scrum.

These features are little pieces of the overall project. A “login process completion” can be considered as a feature in Feature Driven Development (FDD). It is a repetitive and incremental process of development.

With this methodology, a team will be equipped to create, code, design, and inspect code without reverting back to elaborate paperwork and documentation.

The major reason for FDD is to produce tangible software solutions and products consistently and continuously in a timely manner.

FDD helps development teams to update software projects frequently and find errors quickly. Also, this enables clients to be provided with information as well as significant results and progress at any time.

History of Feature Driven Development

In 1997, the first application of Feature Driven Development (FDD) methodology was carried out on a 50-person software development project of 15 months for a financial institution based in Singapore.

This was carried out by a member of the team, Jeff De Luca, to aid the development team in responding and adapting to the needs of the customer.

He created a model that comprises of steps to develop features in short iterations of user stories. The initial project lasted for 15 months and this approach performed excellently.

The initial project was also followed by the second period of 18 months where a 250-person team worked together using the same approach on a software development project.

Feature Driven Development (FDD) has become a go-to pragmatic approach to complex, long-term solutions that hope to implement a simpler agile methodology for their software development.

Feature Driven Development (FDD) can serve as a great choice to development teams that are on the look for a more focused and structured process that is scalable and can continue to deliver tangible solutions and outcomes.

Core Principles of Feature Driven Development

It is imperative to understand the core principles that Feature Driven Development (FDD) follows as part of its development process.

  • Domain object modeling: This is used by the team to model and describe objects and the relationships between them. UML diagrams is an example of object modeling used for this. This helps the team save time by ensuring that the functions needed are added during the modeling phase.
  • Development by feature: Functions that cannot be executed within two weeks are divided into smaller and practicable features.
  • Inspections: This is carried out by the Feature Driven Development (FDD) team to ensure that the best quality is produced and to also find defects in the development process.
  • Single ownership of code: A single owner is assigned each group of code or class.
  • Feature teams: Features are worked on by feature teams that contribute to the design, execution and implementation of that feature.
  • Progress reports: The project manager is encouraged to always provide a progress report of the completed work.
  • Scheduled build: This practice ensures that the team always has the latest iteration or version of the software that can be shown to customers.
  • Configuration management: In this, the source code for all features are documented and identified.

Stages of Feature Driven Development

Feature Driven Development follows five key stages of development which are extensively written to speed up time needed for development and ensure continuous improvements are made to software releases.

Develop overall model

A Feature Driven Development (FDD) project starts with the team researching and creating detailed domain models that is open for peer review. A detailed object model that solves domain problem is developed.

As development and learning occur, more detailed information will be included in the domain models. These domain models are combined overall to create the overall model.

Build a feature list

Through the research employed in the first stage of the FDD process, a list containing the features is created by dividing the domains to subject areas containing information on each business activities.

The processes within these business activities make up the categorized list of features. As mentioned earlier, features in Feature Driven Development (FDD) are small pieces of the function that are valued by clients and are expressed in the form (“actions”, “result”, “objects”).

Examples of these are: “Validate email of a user”, “Calculate the total cost of products in a cart”.

Plan by Feature

The potential risks, complexities, timeframe, dependencies, team members and workload, or any foreseeable obstacle that could affect the development of the features are assessed.

These assessments decide the order of how and when the features on the features list will be carried out. Also, the assessment of the feature complexity is used to determine which team members to assign for that feature or feature set.

Individual developers to be assigned to classes are also determined. Each class of features belong to a specific developer- someone that is responsible for the principles of that class.

For changes that may be needed to be made to groups of classes, each individual developer must collaborate to implement the changes.

Design by Feature

The programmers generate a design package for each feature, and the chief programmer selects the set of features that should be built within two weeks.

The chief programmer will also build detailed object diagrams for each feature while perfecting the model. After completing this step, the class and method prologues will be generated and a design inspection will be performed.

Build by Feature

Once design inspection is completed, team members will work on their individual classes and build tasks. The visual designers will work on the UI, the programmers will work on the code components and so on.

When a feature is completed, QA and unit testing is carried out, the feature will then be pushed to the main build.


Feature Driven Development (FDD) is a useful agile approach that is suitable for complex long-term projects. This is ideal for development teams looking for a simple but structured and scalable agile approach that delivers desired results.



Subscribe to our newsletter!

To keep up to date with all the latest articles, ideas and tips for boosting your team's productivity