You can’t chemical your way out of soil infertility.
– Joel Salatin
Architectural Features Abstract
Every system, whether new or not, eventually requires significant architecture changes in order to be able to support required new business functionality. Therefore, system architecture must be continuously evolved to react to the changing business environment or development velocity will decrease precipitously. In the Framework, we drive system-level architecture initiatives via a specific program backlog item type, Architectural Features.
Architectural features are technical system services that allow developers to implement business features that deliver solution value to the end users and the enterprise. Like business features, architectural features are maintained in the program backlog, where they are identified, prioritized, and justified based on economics. System Architects are often responsible for identifying, splitting and prioritizing these features. Implementation is the responsibility of the Agile teams – a result of collaboration between Agile teams, the system architect, the system team and Product Management.
Architectural features must be split as necessary to fit within PSI boundaries as failure to do so may create an unstable system, which defeats the purpose of the PSI. As with solution features, splitting architectural features and implementing them incrementally is both art and science, and an integral skill necessary for implementing agility at program, and indeed enterprise, scale.
Sources of Architectural Features
Architectural features typically arise from three primary sources:
- As a result of splitting Business and Architecture Epics from the Portfolio Level. For example, a business epic such as “Implement a common install across all products in the suite”, might drive an architectural feature such as “Adapt Corporate Chat Service to use InstallShield”.
- From the Program Vision and Roadmap. For example, a search system might need the ability to “search by keywords”, “build automatic summary of a topic” and “filter search results”. The initial technical response might be to “build an entity extraction mechanism”.
- From some problem with the existing solution. For example a need to “enhance performance” might drive a Nonfunctional Requirement such as “display all user screens in less than 3 sec”. In fact, many NFRs come into existence as a result of architectural features, and they tend to build over time as is illustrated in Figure 1.
Analysis and Modeling of Architectural Features
Every architectural feature can be thought of as a transformation of a system, in which the new system acquires new qualities, as is illustrated in Figure 2.
To achieve this transformation, system models, internal system logic and Non-Functional Requirements (NFRs) change as well. For example, in order to achieve a response time less than 3 sec, internal logic might need to be refactored such that “select data from tables X, Y and Z…” would be transformed into “create indexes for the required fields; select data from X, Y, and Z…; keep the dataset in-memory until modified”. Thinking through the changes is just part of the analysis needed. This analysis also includes:
- Identifying affected areas of the solution
- Splitting the feature
- Identifying acceptance criteria
- Estimating implementation effort, and
- Assessing impact and risks
Implementation requires a synchronized effort of the various “players” in the program.
Agile Teams implement the code for the architectural feature and also:
- Exchange new knowledge about practices and approaches in implementing testing scenarios
- Translate related interfaces, algorithms and component interaction patterns
- Manage dependencies and redundancies as a result of system-wide refactors.
The System Architect supports implementation and typically has the following responsibilities:
- Drives a shared understanding of the feature and understand the plans for implementation
- Attend Agile teams’ planning, backlog grooming, and demo meetings as a subject matter expert and stakeholder
- Work with Product Owners to define acceptance criteria for the features and the technical Stories that result
- Work with the System Team to understand infrastructure changes required to integrate and test the new system
- Use Weighted Shortest Job First, WSJF to prioritize architectural features.
The System Team:
- Implements changes in the integration and testing infrastructure
- Creates new NFR tests to ensure the verification of the system requirements required by the architectural feature
- Provide Agile teams with data sets and test cases for testing associated NFRs.
- Assures that the Program Backlog is optimized with the right balance of business and architectural features
- Ensures that architecture features are implemented in a sequence that facilitates a flow of business features
- Works with product owners to understand the relative impacts and dependencies between business functionality and system qualities.
Architectural features are critical artifacts used to build and extend the Architectural Runway in support of the ongoing implementation of new business features. They provide a mechanism to implement architectural epics within the context of each program and each Potential S.. Increment PSI. Agile teams collaborate with system architects, product management, and the system team to implement architectural features in support of effective technical evolution of the system.
 Leffingwell, Dean. Agile Software Requirements: Lean Requirements Practices for Teams, Programs, and the Enterprise. Addison-Wesley, 2011.
Last update: 15 January, 2013
© 2011-2013 Leffingwell, LLC. All rights reserved.