Bridging Architecture and Agility: Questions from Architecture Meets Agile

Architecture and agility are often seen as opposing forces in software development, but they share more commonalities than differences, especially when it comes to working with people. This episode explores key insights from questions raised during Eberhard’s conference talk ““Architecture and Agility: A Shared Skillset!”, revealing how these disciplines intersect and complement each other.

The People-Centric Nature of Architecture

A key revelation is that architects work more with people than technology. While architecture is typically associated with technical decisions and system structures, successful architects spend significant time communicating, facilitating discussions, and working with teams. This mirrors the agile approach, which emphasizes individuals and interactions over processes and tools.

Balancing Macro and Micro Architecture

One effective way to embrace change while maintaining architectural integrity is through the concept of macro and micro architecture:

• Macro architecture: Decisions that affect all teams and systems (e.g., standardizing on Docker containers)
• Micro architecture: Decisions made at the team level within the established framework

This division provides guardrails while allowing teams autonomy in their specific domains. However, it’s crucial to monitor the balance - too much macro architecture can limit team autonomy and become an agility blocker.

Technology Choices and Team Culture

Technology selections come with inherent cultures and philosophies that influence team dynamics. For example:

• Java often brings an enterprise-focused, conservative culture.
• Smalltalk historically influenced object-oriented practices and testing approaches.
• Different JavaScript frameworks can create distinct team subcultures.

Instead of fighting these cultural aspects, successful architects consider them when making technology choices. The focus should be on finding solutions that align with team preferences and capabilities rather than forcing “ideal” technical solutions.

Documentation and Communication

While architecture documentation is important, it’s just one communication channel. Effective architecture requires multiple forms of communication:

• Written documentation for key decisions and patterns
• Direct conversations for current context and details
• Team discussions for feedback and buy-in
• Tools to enforce architectural boundaries where necessary

Managing Team Disagreements

When teams split into camps over technical choices (like React vs. Vue), the solution isn’t necessarily dictatorial decision-making. Instead, consider:

• Understanding the underlying reasons for preferences
• Evaluating whether multiple approaches can coexist
• Facilitating productive discussions focused on business value
• Using data and evidence where available to inform decisions

Quality Attributes and Business Value

Quality attributes like security, performance, and maintainability should be treated as evolving requirements rather than fixed targets. This means:

• Regularly reassessing quality needs based on business context
• Making quality decisions visible to stakeholders
• Connecting quality attributes to business value
• Being prepared to adjust as requirements change

Buy vs. Build Decisions

Engineering teams often have a natural bias toward building solutions. To make effective buy vs. build decisions:

• Involve domain experts and business stakeholders
• Consider commercial off-the-shelf options early
• Evaluate total cost of ownership, not just development effort
• Recognize that different expertise is needed for evaluation

Conclusion

Successful software architecture in an agile context requires embracing both technical and people aspects. By recognizing that architecture work is fundamentally about people and communication, we can better align architectural practices with agile principles. The key is finding the right balance between structure and flexibility, always keeping business value and team dynamics in mind. The intersection of architecture and agility isn’t about choosing one over the other - it’s about leveraging the strengths of both approaches to create better software systems and mor effective teams.