FDD is a well-known Agile framework ideal for long-running, massive software development projects. It’s a user-centric methodology that can effectively divide large, complex projects into more manageable chunks.
FDD: What is Feature-Driven Development?
Feature Driven Development, or FDD for short, is an Agile framework that focuses on making progress in creating features and organizes project management around it. It’s an iterative, incremental, customer-centric Agile methodology for creating software.
Feature-driven Development (FDD) focuses on developing working software with the necessary features to satisfy client requirements. According to the principles and values of the Agile manifesto, FDD strives to ensure on-time and consistent delivery to the customer.
This framework promotes status reporting at all levels, which helps organizations track results and progress. Feature-driven Development also ensures teams update projects regularly and spot errors quickly. This is one of the most favorite methods among development teams because it helps teams avoid rework and confusion.
The roots of FDD can be traced back to 1997, when IT strategist Jeff de Luka developed the concept. At the time, he was organizing a 15-month project for a bank in Singapore. The project involved 50 team members, and since everything turned out right, it led to widespread acceptance of the FDD model.
FDD has two development processes: incremental and iterative. First, team members break down projects into small increments that are easier to manage, and then the workload is divided into short iterations. In iterations, the developers repeat the steps until they are satisfied with the final result. FDD teams help organizations set up progress reports and perform regular inspections to ensure high-standard services.
Peter Coad was responsible for research on object-oriented design. It's when teams outline the domains of the problem they are trying to solve.
Definition of a Feature
The definition of a feature in Feature-driven development methodology is more similar to a user story in Scrum than to the definition of a feature in Agile. An FDD feature can be fixing an existing issue, such as logging in or adding items to a shopping cart.
A feature in FDD can be deployed every 2 or 10 days, while in Scrum, user stories, which can be viewed as an equivalent of features, should wait 14 days for the Sprint to be finished before being deployed to the users. Features are smaller functions and foundational pieces that the users will find valuable, as FDD is a user-centric methodology that focuses on bringing the users the features they need.
Feature Decomposition
Feature decomposition is used in FDD to break up larger features into smaller and more manageable pieces. Decomposing the feature into smaller parts assures incremental delivery and efficiency. Before a feature is broken down into smaller parts, it needs to be analyzed in detail.
Team members are assigned to each part of the feature based on their experience and skills. Manageable parts in which the feature is divided can be developed, tested, and deployed individually. Decomposing features into more manageable parts allows easier deployment and efficiency, but it also allows the team to focus on parts of the task and regularly track progress on each task.
Feature Prioritization
Feature prioritization in FDD allows teams to work on a prioritized list of features and further develop features that should be created upfront. Feature prioritization allows users to get the features they need as soon as possible, which is how this user-centric approach brings many benefits to the users.
At the same time, feature prioritization allows the team to bring to the users the most desired features while keeping their focus on the features that need to be developed further.
Stages of Feature-Driven Development
Feature-driven development has 5 key stages. Understanding them is key to making the most of this methodology. Each stage plays a key role in developing and guiding a project from start to finish.
- Developing the overall model – during this stage the team determines the project’s scope. They propose multiple models and create one to top them all.
- Setting up a feature list – an outline of the customer-focused features needs to be developed in this stage. For example, the team chooses small functions that can be completed quickly.
- Planning by feature – the team assesses individual features and arranges them properly. These features will then be assigned to different team members.
- Designing by feature – the chief programmer will select which features will be developed in the next two weeks.
- Building by feature – is the final stage. Developers work to develop code for previously mentioned features. The code is tested before creating the final version.
Best Practices for Feature-Driven Development
In software development following 5 key stages of FDD can facilitate incremental development of the software.
The first step of developing the overall model, in practice, ensures that the model is not too specific. It gives the team a general idea of what should be worked on and allows them to brainstorm ideas.
The second step, setting up a feature list, the team describes features, which are user stories, going into detail of user behavior, experience and expectations. This gives the team an insight into which features would be valuable for the user.
Planning by feature allows the team to involve everyone in planning the due dates and deadlines, to ensure everything goes smoothly. Including everyone in this process, ensures to make an accurate estimation of the process and engage team members.
Design by feature step helps the team to prioritize features that they will be working on in the immediate future and collaborate on iteratively bringing the features before users.
The final step in the process, allows all teams involved in the process to collaborate, experiment and test the solutions before they are presented to the users.
Members of FDD
All members of the team using Feature Driven Development have their own unique roles and responsibilities. The team includes the following members’ roles: the chief architect, the development manager, the chief programmer, the domain experts, and the feature teams.
The chief architect holds the responsibility for the creation of an overall model, ensuring the project’s scope aligns with the stakeholder’s needs. As for the development manager, their role is to ensure project’s progress while keeping it within the budget. The responsibility of the chief programmer is to lead the programming team and keep them on track while ensuring the team meets the coding standards as they work on the feature development. The domain experts make sure that the features that are developed meet the standards and users needs. Finally, the feature teams are responsible for developing features, this includes planning, coding, testing, and designing individual features.
When Do You Need FDD?
Compared to other Agile frameworks centered around small teams of disciplined and skilled developers, FDD is mainly focused on larger teams. Additionally, smaller teams might be easier to manage and more likely to succeed, regardless of the Agile method they apply.
On the other hand, not every team member is disciplined and skilled in large teams. This framework uses the so-called "just enough" technique to ensure FDD can be applied to large teams. With this technique, reviewers and planners change and review the assignment of feature sets and classes of developers.
Keep in mind that not all classes are signed simultaneously, only just enough, and as the project grows, the classes keep increasing.
To sum up, you will require FDD Agile if you work on long-term, complex, and large projects. After all, it was created for this purpose. As a result, FDD is considered a functional solution designed to support the management of large projects.
Feature-Driven Development vs. Scrum
While FDD and Scrum are closely related, the first is a feature-focused method instead of a delivery-focused method in Scrum. When it comes to FDD, features are its foundational pieces—small client-valued functions. Features would be equivalent to User stories in Scrum. The advantage of developing a product or making enhancements using smaller features is that they are easier to fix and change, which makes them easier to track and reduces the risk of not delivering the feature on time.
Moreover, FDD values documentation more than other methods, creating differences in the roles of meetings. Also, in Scrum, teams meet daily, while FDD teams use documentation to transfer necessary information; therefore, they don't meet that often.
Another crucial difference is the end-user. In the feature driven development example, the actual user is the end-user, whereas, in Scrum, we have a Product Owner who is seen as an end-user.
We also have differences in sprint length. Even though we can't apply some general rule, in feature flag-driven development, the shorter, the better; in Scrum, a sprint lasts between two and four weeks.
When choosing Agile methodologies, you must pay attention to your project requirements. The good news is that you can use both Feature Driven Development and Scrum for big and more complex software projects.
Pros and Cons of Feature-Driven Development
You may want to consider using this framework if your project becomes too big for smaller teams to handle. For that reason, the agile-feature-driven methodology is more suitable for teams that continuously change and add features to their iterations.
FDD is entirely scalable from small to large cross-functional teams because this approach is designed to accommodate the customers' wants and needs. Now, let's explore some feature-driven development methodology advantages and disadvantages.
Advantages:
- Providing the team with a great understanding of what's expected from them and giving them an insight into the project's context and scope.
- You don't have to spend your time in meetings. While Scrum uses daily meetings, that's not the case with FDD. They rely on documentation to communicate.
- User-centric approach, and in this case, the client is the end-user.
- Great for large-scale and long-term projects. This framework is scalable, and it can grow as your organization grows.
- With the help of FDD, you can break features into smaller chunks, which will make it easier for you to make a quick turnaround, reduce risk, fix coding errors, and track your progress.
Disadvantages:
- FDD is not suitable for smaller projects and doesn't work for those involving developers only.
- It highly depends on the FDD team, especially the chief programmer, who needs to act as a mentor, lead designer, and coordinator.
- It doesn't offer written documentation to clients, even though plenty of documentation circles among team members.
- It is more focused on individual code ownership.
- It may not work well with other systems.
Why Use Feature-Driven Development
Feature-centric development process allows teams to incrementally and iteratively develop features the users need building software and getting tangible results. Feature-driven development allows developers to stay focused on their work, keep the project on track and reduce scope creep.
This methodology allows developers to get results while tracking project’s progress and develop software using a customer-centric approach that provides increased clarity and improves their focus throughout the project.
Challenges in Implementing FDD
When implementing feature based development, the team can encounter various challenges when working towards their goal of bringing users the features they need. Some complex features cannot be easily decomposed into smaller segments, or segments can depend on each other to develop. The potential difficulties with feature decomposition can prevent making progress, especially in the initial stages of the process.
When working together to complete a feature, the team needs to collaborate and communicate to ensure effective collaboration. As feature-driven development is used for large-scale projects, ensuring effective collaboration on complex projects with many segments can become a challenge for the team.
Balancing time and resources can postpone progress and negatively affect efficiency. Feature-driven development doesn’t provide the team with sufficient flexibility, which is another obstacle the teams might face, and they might find it difficult to adapt to ever-changing requirements.
Working with limited resources might provide an additional obstacle to using an FDD approach as it becomes difficult to balance time and resources.
Test-Driven Development vs. Feature-Driven Development
The difference between these two approaches is that test-driven development starts from writing a test that the features should meet, running all the tests, writing the simplest code, rerunning tests and finally refactoring the code if needed.
TDD produces precise solutions, even though it is not as natural as FDD. While FDD is versatile, comprehensive and allows plenty of flexibility, TDD ensures that all features are fully functional, and it creates lean and automatable code.
Feature-Driven Development and ActiveCollab
ActiveCollab is a project management tool that will allow teams to organize their work, plan workload, and organize workflow while using a platform that allows them to communicate and exchange ideas and experiences. Whatever methodology your team chooses to use can be used alongside ActiveCollab to track and manage progress on tasks.
Feature-driven development in Agile can easily be tracked in ActiveCollab by creating different projects and populating task lists with tasks. Each task can be assigned to a team member who will be working on that aspect of a feature, plus the assignee can also track the time they’ve spent working on developing the feature, which facilitates tracking the time spent on tasks.
ActiveCollab is a tool that ensures effective collaboration and gives the managers and teams a tool for equally distributing time and resources, therefore solving one of the greatest challenges feature driven development pmp might face. It allows teams to adequately balance their resources even when they are limited.
In addition, when parts of the feature need to be further divided into smaller segments, ActiveCollab can help teams understand the prioritization by setting due dates on tasks and connecting them with dependencies. Even the most complex projects will be easier to oversee, pull out progress reports, and track progress, with the help of ActiveCollab.
ActiveCollab allows teams to track progress made on a project and prevent issues such as reworking features and avoiding confusion in the process as they strive to provide users with their requirements and meet customer needs.
