“Agile architecture is not about designing everything up front, but about evolving the architecture as the system emerges.” — Martin Fowler.
The Agile Architecture Framework is an iterative and incremental approach for designing architectures.
I developed the Agile Architecture Framework over the span of many years of reviewing architecture and design, as well as creating end-to-end Enterprise solutions at Microsoft.
The Agile Architecture Framework is a way of designing software in small steps that lets you learn and make changes as you go.
It helps you focus on important parts of the design and uses real-world examples to help you make decisions.
It also helps you try out different ideas and see how they work, so you can find the best solution.
Summarizing the Agile Architecture Framework
The Agile Architecture Framework offers a technique that helps scope and focus your architecture exercise, while utilizing scenarios to drive the design and evaluate potential solutions.
By utilizing this approach, you can easily think through your choice of application type, deployment, architectural style, and technologies, while iterating through potential solutions quickly.
Additionally, this framework allows you to map potential patterns and design the best solution for your project.
To summarize, it’s a technique that:
- Scopes and focuses your architecture exercise.
- Uses scenarios to drive the design and evaluate potential solutions.
- Helps you think through your choice of application type, deployment, architectural style and technologies.
- Helps you quickly iterate through potential solutions.
- Helps you map potential patterns.
Here is a summary of the Agile Architecture Framework..
The Agile Architecture Framework at a Glance
Here is how I whiteboard the big idea of the Agile Architecture Framework:
The Agile Architecture Framework is designed to be both iterative and incremental. This means that as you continue to learn and gain more insights, you gradually refine and build upon your initial architecture.
It may not always be immediately obvious what changes need to be made, but through ongoing collaboration and feedback, the architecture can evolve over time to better meet the needs of the project.
This approach allows for greater flexibility and adaptability as the project progresses, rather than trying to predict and plan everything upfront.
Here are the key inputs into the process:
- Use cases and usage scenarios
- Functional requirements
- Non-functional requirements (quality attributes such as performance, security, and reliability)
- Technological requirements
- Target deployment environment
Here are the key outputs of the process:
- Architecturally significant use cases
- Architecture hot spots
- Candidate architectures
- Architectural spikes
Summary of Steps
- Step 1. Identify Architecture Objectives.
- Step 2. Identify Key Scenarios.
- Step 3. Create an Application Overview.
- Step 4. Analyze Key Hot Spots.
- Step 5. Create Candidate Solutions.
Step 1. Identify Architecture Objectives
This is a scoping exercise. The purpose of this step is to figure out how much time and energy to spend on subsequent steps as well as guide your overall effort. You should know what you want in terms of outcomes. Here’s an example of potential goals:
- Build a prototype
- Identify key technical risks
- Test potential paths
- Share models and understanding
Step 2. Identify Key Scenarios
Identify relevant scenarios to focus your design on what matters most, and to evaluate your candidate solutions. In this case, you want to identify architecturally significant use cases. Architecturally significant use cases are those that meet the following criteria:
- They are important for the success and acceptance of the deployed application.
- They exercise enough of the design to be useful in evaluating the architecture.
You can draw key scenarios from your user stories, business stories and system stories.
Step 3. Create an Application Overview
Create an application overview. The application overview serves to make your architecture more real, connecting it to real-world constraints and decisions.
An application overview consists of the following steps:
- Determine your application type. First, determine what type of application you are building. Is it a mobile application, a rich client, a rich internet application, a service, a Web application, or some combination?
- Understand your deployment constraints. Next, understand your targeted deployment environment and determine what impact this will have on your architecture.
- Identify important architectural styles. Determine which architectural styles you will be using in your design. Will you build a service oriented architecture, client/server, layered, a message bus, or some combination?
- Determine relevant technologies. Finally, identify the relevant technology choices based on your application type, architectural styles and deployment constraints.
A good test of an application overview is whether you can whiteboard it.
Step 4. Analyze 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.
Quality Attributes Frame
Understand the quality attributes that are important for your application and scenarios. For instance, most applications need to address security and performance and will be traded against usability, flexibility and other attributes that may be more or less important to you depending on your scenarios and requirements. You can use the following frame to identify key quality attributes to consider:
- How to design for failover support
- How to design a redundant site
- How to plan for backup and recovery How to design for runtime upgrade
- How to isolate from external dependencies
- How to create a migration path from legacy technologies
- How evolve the system without breaking clients
- How to handle dynamic business rules How to handle dynamic UI
- How to handle changes in data and logic processing
- How to handle changes in business requirements
- How to allow applications to interoperate while still evolving separately
- How to isolate systems through the use of service interfaces
- How to isolate systems through the use of mapping layers
- How to reduce dependencies between layers and components
- How to implement a pluggable architecture
- How to choose an appropriate communication model
- How to understand the key types of failure
- How to monitor system operation and health
- How to modify system behavior based on load
- How to determine a caching strategy
- How to design high performance communication between layers
- How to design high performance data access
- How to manage resources effectively
- How to handle unreliable external systems
- How to audit requests and jobs
- How to redirect load
- How to handle failed communication
- How to handle failed transactions
- How to handle exceptions
- How to reduce duplication between components and layers
- How to share functionality across systems
- How to share functionality across components and layers
- How to design layers and tiers for scalability
- How to scale-up or scale-out
- How to handle spikes in traffic and load
- How to address authentication and authorization.
- How to protect against malicious input.
- How to protect sensitive data
- How to design auditing and logging
- How to design usable error messages
- How to design for testability
- How to design unit tests
- How to design for UI automation
- How to design for user empowerment
- How to improve responsiveness
- How to avoid common user experience pitfalls
Architecture Hot Spots Framework
The Architecture Hot Spots Framework represents cross cutting concerns that will impact your design across layers and tiers. These are also the areas in which high impact design mistakes are most often made. Use the architecture frame to identify hot spots in your design that require additional attention to get right. You can use the following architecture frame to identify cross cutting concerns in your design:
Authentication and Authorization
- How to choose an authentication strategy.
- How to choose an authorization strategy.
- How to flow identity across layers and tiers.
- How to store user identities when not using Active Directory.
Caching and State
- How to choose an appropriate caching technology.
- How to determine what data to cache.
- How to determine where to cache the data.
- How to determine the expiration policy.
- How to choose appropriate protocols for communication across layers and tiers.
- How to design loose coupling across layers.
- How to perform asynchronous communication.
- How to pass sensitive data.
- How to choose a composition pattern for the user interface (UI).
- How to avoid dependencies between modules in the UI.
- How to handle communication between modules in the UI.
Concurrency and Transactions
- How to handle concurrency between threads.
- How to choose between optimistic and pessimistic concurrency.
- How to handle distributed transactions.
- How to handle long running transactions.
- How to determine what information needs to be configurable.
- How to determine where and how to store configuration information.
- How to protect sensitive configuration information.
- How to handle configuration information in a farm/cluster.
Coupling and Cohesion
- How to choose an appropriate layering strategy for separation of concerns.
- How to design highly cohesive components and group them within layers.
- How to determine when loose coupling is appropriate between components within a layer.
- How to manage database connections.
- How to handle exceptions.
- How to improve performance.
- How to handle binary large objects (blobs).
- How to handle exceptions.
- How to log exceptions.
- How to provide notification when required.
Logging and Instrumentation
- How to determine which information to log.
- How to make the logging configurable.
- How to determine what level of instrumentation is required.
- How to improve task efficiency and effectiveness.
- How to improve responsiveness.
- How to improve user empowerment.
- How to improve look and feel. </>
- How to determine where and how to perform validation.
- How to validate for length, range, format, and type.
- How to constrain and reject input.
- How to sanitize output.
- How to choose the appropriate workflow technology.
- How to handle concurrency issues within a workflow.
- How to handle task failure within a workflow.
- How to orchestrate processes within a workflow.
Step 5. Create Candidate Solutions
Create a candidate architecture and along with architectural spikes and evaluate it against your key scenarios, hot spots, and deployment constraints. The outcomes of this step are:
- Baseline / Candidate Architectures
- Architectural Spikes
Iterative and Incremental Design
You can iteratively flesh out your architecture as you work through your design and discover more details that impact your architecture.
You don’t have to design your architecture in a single iteration.
Do not get lost in the details; focus on the big steps and build a framework on which you can base your architecture and design.
Embracing the Agile Architecture Framework for Designing Better Architectures
The Agile Architecture Framework offers a comprehensive, yet flexible approach to designing architectures that can be adapted to meet the specific needs of a project.
By scoping and focusing the architecture exercise, using scenarios to drive the design, evaluating potential solutions, and mapping potential patterns, the framework empowers development teams to iterate quickly, respond to changes, and ultimately deliver high-quality software.
As technology continues to evolve and the demands of the industry shift, the Agile Architecture Framework remains a valuable tool for any team looking to achieve success in software development.
You Might Also Like
Agile Lifecycle Framework
Agile Content Development Framework
Agile Performance Engineering Framework
Agile Security Engineering Framework
Extreme Programming at a Glance
How Agile and Lean Help Business
Roles on Agile Teams
Scrum at a Glance
Software Methodologies at a Glance
Waterfall to Agile
What is Agile?