In the past, my colleagues and I have written several blogs on the combination of enterprise architecture and agile ways of working (e.g. Enterprise Architecture and Agile Development: Opposites Attract?, Enterprise Architecture and Innovation: A cultural change, Escaping the Jaws of the Project Monster). In this blog, I want to focus in more detail on the use of the ArchiMate language in the context of agile methods, in particular the Scaled Agile Framework (SAFe).
For those of you who are not familiar with SAFe, this is a framework for organizing agile-in-the-large (AITL), used by large enterprises that need to coordinate the efforts of many agile teams around the same set of strategic goals. The SAFe framework is just a way to illustrate the use of ArchiMate in agile frameworks. The figure below presents a simplified picture of SAFe, in its three-level incarnation. This depicts several concepts used in SAFe and other agile methods. It is not our aim to explain these in detail; please refer to the SAFe website if you want to know (much) more. In this blog post, we will only provide a brief summary.
Mapping SAFe concepts to ArchiMate
In the table below, we demonstrate how you can use ArchiMate elements to express these concepts. At the Portfolio level, the strategy and high-level motivation elements from ArchiMate 3.0 (Course of Action, Capability, Resource, Gola and Outcome) can be used fruitfully. Capability-based planning can be a good starting point for investment discussions at this level. The initial view on the architecture is expressed at a high level using ArchiMate’s core concepts. The work needed is managed using a portfolio of Work Packages, which typically represent programs at this level (remember that ArchiMate uses a single concept at all levels of detail, from entire programs down to individual tasks).
|Strategic theme||Stakeholders & Drivers, Goals, Course of Action|
|Epic, Enabler||Goals, Outcomes, Capabilities, Resources, Core concepts (high-level)|
|Program portfolio||Work Packages and Deliverables|
|Vision||Outcomes, Requirements, Constraints|
|Roadmap||Series of Plateaus, Deliverables|
|Architecture Runway||Core concepts (more detailed)|
|Features||Requirements & Constraints|
|User & Architecture Stories||Requirements & Constraints (more detailed)|
|Sprint result (product increment)||Deliverables & Plateau|
At the Program level, we see that the program vision is expressed in the desired outcomes, the Roadmap is represented by a series of Plateaus and associated Deliverables, the Architecture Runway expressed in ArchiMate’s core concepts, and the (medium-level) Requirements and Constraints that need to be fulfilled by the solution. Finally, at the team level we mainly see the expression of User and Architecture Stories with Requirements and Constraints, the product increment, consisting of one or more Deliverables, results in a Plateau (a stable state in the architecture).
Note that details of the solution are typically not expressed in ArchiMate. It is, after all, a language intended for enterprise architecture. Software design is usually better done using UML (and in some cases BPMN or other implementation-level modeling languages). It is, however, quite easy to link your ArchiMate models to this implementation level. On the one hand, several concepts in your Architecture Runway could be mapped directly to corresponding implementation-level elements, such as Application Components, Interfaces and Services in UML, or Business Processes in BPMN. See also our previous blogs on linking ArchiMate with UML and BPMN.
Relationships with other concepts and tools to support traceability
Next to the relationship between these concepts that express the solution, the relationship with user and architecture stories is also significant. Agile teams typically use issue-tracking tools like Jira or Bugzilla to administrate these. Linking BiZZdesign Enterprise Studio to such tools provides you with end-to-end traceability from high-level strategic goals down to individual user stories and back. This provides very useful insights to prioritize and allocate budgets and resources on the one hand, and to monitor progress towards achieving business outcomes on the other.
Moreover, the architecture backbone provided by ArchiMate models is invaluable in tracking the various dependencies between different initiatives, programs and results. This is a main challenge to scaling agile to the enterprise level: if you don’t coordinate between individual teams, they will each build their own agile silos, and you are often left with instant legacy.
This traceability between the different levels means that you know where changing strategies and requirements may have an impact, you can ensure the coherence and stability of your IT landscape, and you are demonstrably in control, which is increasingly important in a sometimes highly regulated business environment.
This does not mean that we advise you to create ‘big design up front’ ArchiMate models that capture the entire design before you build anything. Rather, it is better to create and evolve just-in-time models that capture the information necessary to make the right decisions at the right moment. This way, your organization can become a truly Adaptive Enterprise!