Software Architecture: The Hard Parts (1 Day)

Format: Live Virtual Training
Duration: 1-Day Class

Software architects have no clean, easy decisions: everything is a terrible tradeoff. Architecture has lots of difficult problems, which this platform-agnostic class highlights by investigating what makes architecture so hard. This hands-on, platform-agnostic architecture class goes beyond the fundamentals of software architecture and focuses on the really hard problems. This class focuses primarily on aspects of distributed architectures and on areas surrounding modularity versus granularity, the challenges of event-driven architectures (including difficult error handing issues), distributed architecture patterns and how to decouple services to achieve proper granularity. Architecture is full of hard parts; by attending this workshop you can gain the insights and techniques to make it just a little softer.

This 1 day virtual live class is scenario-based, with each topic asking and answering some of the harder questions in software architecture. Students will undergo hands-on exercises (scenarios) after each topic area to exercises the concepts learned in that hard part.

For more information about the pricing and availability of this course for private (corporate) training, please contact me at For public training offerings for this course, please see my public schedule at my upcoming events page. 

Public Training Dates
See the Public Course Schedule page for scheduled dates for this class

Course Agenda (1-Day Virtual Class)

How do I analyze tradeoffs and document architecture decisions?

  • Architecture Decision Records  
  • ATAM Utility Trees
  • Example Tradeoff Decision 

How do I choose and appropriate architecture?

  • Architecture Topology and Style Decision Criteria  
  • Fallacies of Distributed Computing
  • Hands-on Scenario: Monolithic or Distributed?

When should I break apart my application or service?

  • Service Granularity Drivers

How do I determine the appropriate level of granularity?

  • Granularity Factors
  • Hands-on Scenario: Determining Service Granularity

In what situations should I use choreography?

  • Defining Service Choreography
  • Examples of Choreography
  • Tradeoffs

In what situations should I use orchestration?

  • Defining Service Orchestration
  • Examples of Orchestration
  • Tradeoffs
  • Hands-on Scenario: Orchestration or Choreography?

In what situations should I use ACID vs. BASE (distributed) transactions?

  • ACID Transactions
  • BASE Transactions
  • Workflow Implications

How do I handle workflow and transactions in a distributed architecture?

  • Transactional Sagas
  • Patterns of Eventual Consistency
  • Hands-on Scenario: Identifying Transactional Sagas

How do I create systems with high semantic coupling but low syntactic coupling?

  • Semantic vs. Syntactic Couling
  • Value-Driven Contracts

How do I automate architecture and contract governance?

  • Fitness Functions
  • Fitness Function Tools
  • Example Fitness Function 
  • Hands-on Scenario: Fitness Functions for Contract Governance

How do I manage data in a distributed system?

  • Data Ownership
  • Data Access Techniques
  • Hands-on Scenario: Data Ownership and Access

How do I give a higher priority for important or critical transactions?

  • Ambulance Pattern
  • Carpool Pattern
  • Example and Demo

How do I achieve high levels of scalability and elasticity in a system?

  • Patterns for Scalability
  • Patterns for Elasticity
  • Hands-on Scenario: Achieving Elasticity
©2020 DeveloperToArchitect