Agile Architecture Method Explained - Chapter 1 - Agile Architecture Method

From Guidance Share

Jump to: navigation, search

- J.D. Meier , Alex Homer, David Hill, Jason Taylor , Prashant Bansode , Lonnie Wall, Rob Boucher Jr, Akshay Bogawat.



  • Learn the inputs required for beginning the design process.
  • Learn the typical results of the design process.
  • Learn the key steps to iteratively design a suitable architecture for your application.
  • Learn the guidelines to follow while designing the architecture.
  • Learn an effective approach for reviewing the architecture.


A successful approach to architecture design requires you to follow a series of steps that ensure you consider all of the relevant factors affecting the architecture, and then repeat these steps as you refine your design. This chapter recommends a series of five main steps, each of which breaks down into individual processes about which you will see more details throughout the remainder of the guide.

Your design starts with inputs that describe the requirements and define the deployment infrastructure limitations. The end result of the design process is an architecture that matches the requirements with these physical limitations. Along the way, you will identify your objectives, define the key scenarios, gain an understanding of the overall design, and be able to identify key hotspots that require specific attention. The result will be a candidate solution that you can further refine by repeating the steps, finally creating the best-fit architecture design for your application.


The following list represents assets that are useful to have in hand when designing your architecture:

  • Use cases and usage scenarios
  • Functional requirements
  • Non-functional requirements (quality attributes such as performance, security, and reliability)
  • Technological requirements
  • Target deployment environment
  • Constraints


The steps in this chapter should result in the following assets:

  • Architecturally significant use cases
  • Architecture hot spots
  • Candidate architectures
  • Architectural spikes


Figure 1 shows the five major steps for designing your architecture.


Figure 1: Core Architecture Design Activities

These steps are:

  • Step 1. Identify Architecture Objectives. Clear objectives help you to focus on your architecture, and on solving the right problems in your design. Good objectives help you to determine when you have completed the current phase, and when you are ready to move to the next phase.
  • Step 2. Key Scenarios. Use key scenarios to focus your design on what matters most, and to evaluate your candidate architectures when they are ready.
  • Step 3. Application Overview. Understand your application type, deployment architecture, architectural styles, and technologies in order to connect your design to the real world in which the application will have to operate.
  • Step 4. Key Hot Spots. Identify key hotspots based on quality attributes and the architecture frame. These are the areas where mistakes are most often made when designing an application.
  • Step 5. Candidate Solutions. Create a candidate architecture or architectural spike and evaluate it against your key scenarios, hot spots, and deployment constraints.

You can iteratively flesh out your architecture as you work through your design and discover more details that impact your architecture. You should not always try to build your architecture in a single iteration. Don’t get lost in the details; focus on the big steps and build a framework on which you can base your architecture and design.

Iterative and Incremental Architecture

This architectural process is meant to be an iterative and incremental approach. Your first candidate architecture will be a high-level design that you can test against key scenarios, requirements, known constraints, quality attributes and the architecture frame. As you create your candidate architecture, and any architecture spikes, you will learn more details about the design and will be able to further flesh out key scenarios, your application overview, and your approach to hotspots. Each iteration should add more details to your design.

Agile Considerations

Use system stories and user stories to pin your requirements against specific instances of use cases that can be tested against. A good story will intersect the user view, the system view and the business view of the architecture. Use stories to test your design and determine where the breaking points may be. A system story describes the application scenarios from the system’s perspective as seen through the lens of quality attributes. A user story describes what the application should do from the point of view of the customer. In this case, you would create stories around usage, and evaluate against your quality attributes. You should be able to complete development of the features to implement a story within a single iteration. You may need to develop new stories as you create and update your architecture model.

Consider the following when you plan your stories:

  • Early in the project, reduce risk by creating a candidate architecture that supports architecturally significant end-to-end scenarios that exercise all layers of the architecture.
  • Using your architecture model to guide you, make changes to your architecture, design, and code to meet your scenarios, functional requirements, technological requirements, quality attributes, and constraints.
  • Create an architecture model based on what you know at the time, and define a list of questions that must be addressed in subsequent stories and iterations.
  • After you make sufficient significant changes to the architecture and design, consider creating a story that reflects these changes. Batch together the small changes in the architecture and design and address them together.

When creating your architectural spikes, consider the following:

  • Understand your key risks and adapt your design to reduce these risks.
  • Sharing information is critical in an agile approach; optimize your deliverables for effective and efficient communication of design information.
  • Build your architecture with flexibility and refactoring in mind. You may need to modify you architecture a number of times so optimize around this possibility.
Personal tools