Feature Driven Development (FDD)

Feature-driven development (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 five steps in FDD

There are five key activities in Feature-Driven Development:

Develop the overall model. Here, an FDD team will determine the project scope. Multiple models will be proposed and merged to create one overall model;
Build the features list. Next, the team members will outline the customer-focused features to be developed. They will be small functions that can be completed in a short period of time. An example could be to create an automatic reminder for subscription renewal;
Plan by feature. The team will assess the individual features in the list and arrange them in the appropriate order. Then, the features will be assigned to team members;
Design by feature. At this stage, the team’s chief programmer will choose which features to develop within a two-week period. A design package will be created for each feature, and team members will conduct a review before building commences;
Build by feature. Developers work to build the code for the aforementioned features. This code will be tested before the final version is created.

Members of the FDD team

The FDD modeling team includes the following main roles:

The project manager oversees the entire project;
The chief architect is in charge of the overall design and modeling of the system. The chief architect works with other skilled developers in the planning phase of the development cycle;
The development manager leads and mentors the development team and oversees the day-to-day programming activities;
The chief programmer helps with analysis and design and may also be assigned to manage small development teams;
The class owner is a member of the smaller development teams that are led by the chief programmer. Responsibilities include designing, coding, testing, and documenting features;
The domain expert is a member of a team that understands the problem that the customer needs to be solved. The developers rely on the domain expert’s knowledge to ensure that they are working and delivering what is most important to the customer.

Best practices for feature-driven development

Domain object modeling: Teams build class diagrams to describe objects in a domain and the relationships between them. This process saves time by helping you uncover what function to add for each feature;
Developing by feature: If a function cannot be implemented within two weeks, it should be broken down into smaller, manageable features;
Individual class (code) ownership: Each class or group of code is assigned to a single owner;
Feature teams: Although one person is responsible for the performance and quality of each class, a feature may involve more than one class, so everyone in the feature team contributes to design and implementation decisions;
Inspections: FDD teams perform inspections to detect defects and ensure the best quality;
Configuration management: This practice involves identifying source code for all features and documenting changes;
Regular build schedule: This best practice will make sure that the team always has an up-to-date system that they can demonstrate for the client;
Progress reports: Project managers should provide frequent progress reports of completed work.

The Pros of Feature-Driven Development

There are several potential benefits to using feature-driven development (FDD) as a software development methodology:

Focused scope: By focusing on the delivery of small, incremental features, FDD helps to ensure that the development team stays focused on a well-defined scope of work, which can help to reduce the risk of scope creep and keep the project on track;
Early and frequent delivery: FDD emphasizes the delivery of working software to the customer as quickly as possible. This allows the customer to see progress and provides the opportunity for early feedback, which can help to ensure that the final product meets their needs;
Improved communication: FDD places a strong emphasis on communication and collaboration between team members. This can help to improve the flow of information between team members and ensure that everyone is working towards a common goal;
Increased flexibility: FDD is an agile methodology, which means that it is designed to be flexible and responsive to changing requirements and priorities. This can help to ensure that the development team is able to adapt to changing circumstances and deliver a product that meets the customer’s needs;
Better project management: FDD emphasizes the use of effective project management practices, such as iterative development and the use of short, time-boxed development cycles. This can help to ensure that the project stays on track and meets its objectives.

The Cons of Feature-Driven Development

There are a few potential drawbacks to using feature-driven development (FDD) as a software development methodology:

Complexity: FDD can be more complex than other agile methodologies, as it involves a series of small, well-defined steps that must be followed in order to deliver a feature. This can make it more difficult for new team members to understand and adopt the methodology;
Time and resources: FDD requires a significant investment in time and resources in order to be successful. It involves a series of small, incremental development cycles, which can be time-consuming to plan and execute;
Dependencies: FDD relies on the delivery of small, incremental features in order to make progress. This can create dependencies between features, which can impact the overall delivery schedule if one feature takes longer to develop than expected;
Limited visibility: FDD focuses on the delivery of small, incremental features, which can make it difficult to see the overall progress of the project. This can make it challenging for stakeholders to understand the project’s overall direction and progress;
Limited control: FDD emphasizes the delivery of small, incremental features, which can limit the team’s control over the final product. This can make it difficult to ensure that the product meets the customer’s needs and aligns with the project’s overall goals and objectives.