Feature-Driven Development (FDD)

Introducing Feature-Driven Development

Feature-Driven Development (FDD) is a methodical and structured approach to Agile software development, primarily focused on the delivery of client-valued features.

With its roots firmly in the Agile methodology, Feature-Driven Development combines time-tested best practices with an emphasis on clear, iterative progress and a feature-centric process. This development methodology is particularly effective for larger teams and projects thanks to its scalable nature and straightforward principles.

The origins of FDD

Jeff De Luca, during the 1990s, formulated Feature-Driven Development while working on a large-scale banking software project. His collaboration with industry expert Peter Coad led to the formalisation of FDD.

Feature-Driven Development was designed to address the complexity of software projects by breaking them down into manageable chunks of client-valued features, thus streamlining the development process and ensuring alignment with user needs.

Feature-Driven Development is geared towards larger teams and projects, emphasising a pragmatic blend of industry best practices with a focus on building tangible, working software incrementally. It’s particularly useful when the software project is complex and domain-specific, requiring frequent interaction and communication with domain experts.

Core values and principles

At the heart of Feature-Driven Development lies a set of core values and principles: a focus on frequent, tangible deliverables; a commitment to building by feature; and an emphasis on simplicity and establishing clear roles within a development team. These guiding tenets enable teams to deliver quality software in a predictable manner, ensuring that each feature adds value to the final product and aligns with client priorities.

FDD’s five processes

Feature-Driven Development is characterised by five sequential processes that guide software development from start to finish. These processes form a framework that encourages transparency, regular feedback, and systematic progression. Together, they enable teams to efficiently build and refine software features, ensuring a high-quality result that aligns with client needs.

Feature-Driven Development is an iterative and incremental software development methodology intended to provide consistent, repeatable results in software development by following a set of best practices.

Here are the key processes in implementing FDD:

1. Develop an overall model

• Initial project setup: The project scope and context are set up.
• Domain object modelling: Work with domain experts to develop a high-level model of the domain.
• Feature list: Identify a list of high-level features that will be included in the software.

2. Build a features list

• Categorising: Organise the features into related groups.
• Prioritising: Prioritise features based on business value or technical risk.
• Assigning: Assign features to specific development teams or team members.

3. Plan by feature

• Feature schedule: Develop a schedule based on feature dependencies and priorities.
• Resource allocation: Assign resources to the scheduled features.
• Risk assessment: Assess risks associated with each feature and plan to mitigate them.

4. Design by feature

• Design workshops: Conduct workshops to flesh out the details of each feature.
• Design inspection: Review the design for quality and adherence to project standards.
• Feature design documentation: Document the design decisions made during this phase.

5. Build by feature

• Build feature: Code the feature according to the design, usually by a feature team.
• Code inspection: Conduct code reviews to ensure adherence to coding standards.
• Unit testing: Perform unit testing to catch bugs early and ensure feature quality.
• Promotion to build: Merge the completed feature into the main build for further integration testing.

Iterating through the process

Feature-Driven Development promotes iterating through these steps in a cyclic manner. After completing a feature, the team revisits the planning and design steps for the next set of features.

Throughout the process, there is continuous integration and testing to ensure that new code integrates smoothly with the existing codebase.

Tracking progress and reporting

• Progress tracking: Monitor the development of features against the project timeline.
• Reporting: Regularly report the progress of the project to stakeholders.
• Adjusting plans: Adjust plans and schedules as needed based on feedback and project realities.

Developing by feature

Developing by feature focuses on delivering specific, client-valued features following the planned sequence. This approach deconstructs complex software systems into smaller, manageable segments, allowing teams to concentrate on delivering functional increments of the product. It streamlines the development process and facilitates a more straightforward quality control and code maintenance.

Managing and tracking progress

Managing and tracking progress are central to the FDD framework. These practices involve regular, predefined build schedules and progress reporting mechanisms, ensuring that the project’s momentum continues unhindered.

Visual progress charts, such as burn-up or burn-down charts, provide clear indicators of the project’s state, allowing teams to celebrate achievements and quickly identify and rectify any deviations from the planned path. This consistent oversight plays a crucial role in the on-time delivery of a high-quality software product.

FDD in contemporary software development

Feature-Driven Development remains a vital approach within contemporary software development. Its adaptability and rigorous focus on client-valued features make it a compelling choice, even as Agile practices evolve. FDD’s unique structure offers a clear pathway through the complexity of modern software projects while aligning with the key tenets of agility.

Agile integration and scaling

FDD’s natural compatibility with Agile principles allows it to integrate seamlessly into the Agile landscape. It supports the Agile emphasis on collaboration, iterative progress, and responsiveness to change. The methodology scales effectively for larger teams and complex projects without losing the essence of feature-centric development, thus serving a broader range of project sizes and types.

Comparing FDD with other Agile methodologies

When juxtaposed with frameworks like Scrum or Extreme Programming (XD), FDD holds its ground with its unique focus on feature-driven progress and predefined processes. Unlike Scrum, which pivots on time-boxed iterations known as Sprints, FDD is feature-timed, offering a different rhythm and planning focus. Extreme Programming (XP) emphasises technical best practices and pair programming, whereas FDD provides a blend of high-level model-driven design and feature-centric planning. Each framework brings its advantages to various project scenarios, with FDD standing out for its structured pathway to developing robust software features.

Implementing FDD in your organisation

Feature-Driven Development (FDD) offers a strategic blueprint for software development that is both structured and client-centric. For organisations looking to adopt FDD, the transition involves understanding its methodology, assembling the right team, and integrating it with existing practices.

This transition demands a thorough approach, with an emphasis on proper training, effective team structuring, and clear communication of expectations. The end goal is not merely to follow a set of processes but to enhance the team’s productivity and the quality of the software developed.

Starting to use TDD in your teams

Adopting new Agile practices such as Feature-Driven Development can be difficult for many individuals and teams because it requires new ways of working. Adoption of the new practices is helped if the team undergoes Agile training and gets support from an experienced Agile coach.

Contact agileKRC to find out how our expert Agile consultants can help your organisation achieve its objectives on its journey towards Agile transformation.

Building effective feature teams

The core unit of FDD is the feature team, composed of members with different expertise working together towards common goals. Effective feature teams are cross-functional, with clear roles and a shared commitment to delivering valuable features.

To build such teams, fostering a culture of collaboration is imperative, along with a focus on individual strengths and continuous learning. This ensures a unified effort towards feature-centric development, leading to improved productivity and project delivery.

Measuring success with FDD

Determining the success of FDD within an organisation involves tracking specific metrics that reflect the efficiency and quality of the development process. These indicators might include the frequency and volume of feature delivery, the robustness of the code, and feedback from stakeholders.

Regular assessment of these metrics enables continuous improvement, ensuring that FDD is contributing positively to the development lifecycle and that each iteration adds substantial value to the end product.