Software Architecture Monday with Mark Richards is a free monthly software architecture lesson containing a short video about some aspect of software architecture. These lessons contain tips, techniques, and advice to help you in your journey from developer to architect. New lessons will be posted on the first Monday each month.
All Lessons
Microservices Lessons
General Architecture Lessons
Event-Driven Architecture Lessons
Soft Skills Lessons
Integration Architecture Lessons
Enterprise Architecture Lessons
- Lesson 206 - Architecture Decisions: Overcoming Analysis Paralysis (April 7, 2025)
- Lesson 205 - Fundamentals of Software Architecture 2nd Edition (March 3, 2025)
- Lesson 204 - Risk Storming For Architects (February 3, 2025)
- Lesson 203 - Understanding Architecture Style Risks (January 6, 2025)
- Lesson 202 - Frequently Overlooked Architectural Characteristics (December 16, 2024)
- Lesson 201 - Microservices Communication Protocols (December 2, 2024)
- Lesson 200 - A Call To Action (November 18, 2024)
- Lesson 199 - Event-Driven Architecture: Anemic Events (November 4, 2024)
- Lesson 198 - The Swarm of Gnats Event AntiPattern (October 21, 2024)
- Lesson 197 - Communication Patterns (October 7, 2024)
- Lesson 196 - Modularity and Architectural Styles (September 23, 2024)
- Lesson 195 - Sacrificial Architecture (September 9, 2024)
- Lesson 194 - Architecture as Code (August 26, 2024)
- Lesson 193 - Identifying Components: The Actor/Action Approach (August 12, 2024)
- Lesson 192 - Identifying Components: The Workflow Approach (July 29, 2024)
- Lesson 191 - The Entity Trap (July 15, 2024)
- Lesson 190 - Logical vs. Physical Architecture (July 1, 2024)
- Lesson 189 - Architectural Quantum Tradeoffs (June 17, 2024)
- Lesson 188 - Identifying Architectural Characteristics (June 3, 2024)
- Lesson 187 - Categorizing Architectural Characteristics (May 20, 2024)
- Lesson 186 - Fallacy #11: Observability is Optional (May 6, 2024)
- Lesson 185 - Residuality Theory (April 22, 2024)
- Lesson 184 - Running an Architecture Kata Session (April 8, 2024)
- Lesson 183 - Head First Software Architecture Book (March 25, 2024)
- Lesson 182 - Domain to Architecture Isomorphism Part 3 (March 11, 2024)
- Lesson 181 - Feasibility and Questioning Requirements (February 26, 2024)
- Lesson 180 - Domain to Architecture Isomorphism Part 2 (February 12, 2024)
- Lesson 179 - Domain to Architecture Isomorphism Part 1 (January 29, 2024)
- Lesson 178 - Multi-Broker Pattern (January 15, 2024)
- Lesson 177 - Logical Architecture Components (January 1, 2024)
- Lesson 176 - Compensating Updates Revisited (December 18, 2023)
- Lesson 175 - Events vs. Messages (December 4, 2023)
- Lesson 174 - Replicated Caching and Data Collisions (November 20, 2023)
- Lesson 173 - Leveraging Checklists (November 6, 2023)
- Lesson 172 - TOGAF in 10 Minutes (October 23, 2023)
- Lesson 171 - Producer Control Flow Pattern (October 9, 2023)
- Lesson 170 - Managing Code Reuse in Microservices (September 25, 2023)
- Lesson 169 - Atomic vs. Eventual Transactions (September 11, 2023)
- Lesson 168 - ADRs and Architecture Stories (August 28, 2023)
- Lesson 167 - Architecture vs. Design (August 14, 2023)
- Lesson 166 - Space-Based Architecture (July 31, 2023)
- Lesson 165 - Event-Driven Architecture (July 17, 2023)
- Lesson 164 - Service-Oriented Architecture (July 3, 2023)
- Lesson 163 - Service-Based Architecture (June 19, 2023)
- Lesson 162 - Microservices Architecture (June 5, 2023)
- Lesson 161 - Agility and Monolithic Architectures (May 22, 2023)
- Lesson 160 - Microkernel Architecture (May 8, 2023)
- Lesson 159 - Modular Monolith Architecture (April 24, 2023)
- Lesson 158 - Layered Architecture (April 10, 2023)
- Lesson 157 - Incorporating ADRs Into Existing Systems (March 27, 2023)
- Lesson 156 - The Zachman Framework in 10 Minutes (March 13, 2023)
- Lesson 155 - The Infinity Architecture AntiPattern (February 27, 2023)
- Lesson 154 - Is an ESB Still Relevant Today? (February 13, 2023)
- Lesson 153 - Service-Based Architecture vs. SOA (January 30, 2023)
- Lesson 152 - Modeling Distributed Workflows (January 16, 2023)
- Lesson 151 - Software Architecture Roles and Titles (December 19, 2022)
- Lesson 150 - Quantitative vs. Qualitative Analysis (December 4, 2022)
- Lesson 149 - Caching and CAP Theorem (November 21, 2022)
- Lesson 148 - The Fallacies of Compensating Updates (November 6, 2022)
- Lesson 147 - The Fallacies of Versioning (October 23, 2022)
- Lesson 146 - The Out-of-Context Scorecard AntiPattern (October 10, 2022)
- Lesson 145 - Analyzing Tradeoffs (September 26, 2022)
- Lesson 144 - Using Redirection to Solve Problems (September 12, 2022)
- Lesson 143 - Problem Solving Checklist (August 29, 2022)
- Lesson 142 - Request/Reply vs. Async Notification (August 15, 2022)
- Lesson 141 - Managing Architecture Decisions (August 1, 2022)
- Lesson 140 - Governing Data Services (June 6, 2022)
- Lesson 139 - Triggered vs Continuous Fitness Functions (May 23, 2022)
- Lesson 138 - Dynamic Quantum Entanglement (May 9, 2022)
- Lesson 137 - REST vs Messaging (April 25, 2022)
- Lesson 136 - Managing Shared Database Changes (April 11, 2022)
- Lesson 135 - Scalability Revisited (March 28, 2022)
- Lesson 134 - What is a Service? (March 14, 2022)
- Lesson 133 - Stovepipe Architecture AntiPattern (February 28, 2022)
- Lesson 132 - Architecture by Implication AntiPattern (February 14, 2022)
- Lesson 131 - Microservices vs. Event-Driven Architecture (January 31, 2022)
- Lesson 130 - The Frozen Caveman AntiPattern (January 17, 2022)
- Lesson 129 - Assessing Architectural Risk (Part 3) (December 20, 2021)
- Lesson 128 - Assessing Architectural Risk (Part 2) (December 6, 2021)
- Lesson 127 - Assessing Architectural Risk (Part 1) (November 22, 2021)
- Lesson 126 - Is SOA Dead? (November 8, 2021)
- Lesson 125 - Managing Broad Bounded Contexts (October 25, 2021)
- Lesson 124 - The Challenges of Distributed Architectures (October 11, 2021)
- Lesson 123 - Composite Architecture Characteristics (September 27, 2021)
- Lesson 122 - When Should You Replace Your Architecture? (September 13, 2021)
- Lesson 121 - Transacted Messages (August 30, 2021)
- Lesson 120 - Domain vs. Technical Partitioning (August 16, 2021)
- Lesson 119 - Why Enterprise Architecture Efforts Fail (August 2, 2021)
- Lesson 118 - Limiting Assumptions (July 19, 2021)
- Lesson 117 - Accidental Complexity AntiPattern (July 5, 2021)
- Lesson 116 - Negotiation Tips for Software Architects (June 21, 2021)
- Lesson 115 - Email-Driven Architecture (June 7, 2021)
- Lesson 114 - Microservices vs Service-Based Architecture (May 24, 2021)
- Lesson 113 - Cart Before The Horse Anti-Pattern (May 10, 2021)
- Lesson 112 - Architecture Characteristics Worksheet (April 26, 2021)
- Lesson 111 - CAP Theorem Illustrated (April 12, 2021)
- Lesson 110 - The Pros and Cons of Event-Driven Architecture (March 29, 2021)
- Lesson 109 - BASE Transactions and Eventual Consistency (March 15, 2021)
- Lesson 108 - The Role of a Software Architect (March 1, 2021)
- Lesson 107 - Microservices Annotations and Attributes (February 15, 2021)
- Lesson 106 - Architecture Stories (February 1, 2021)
- Lesson 105 - Stamp Coupling (January 18, 2021)
- Lesson 104 - Architecture Styles FAQ #1 (January 4, 2021)
- Lesson 103 - Balancing Architecture and Hands-On Coding (December 21, 2020)
- Lesson 102 - Architecture Characteristics FAQ (December 7, 2020)
- Lesson 101 - Components and Root Namespaces (November 23, 2020)
- Lesson 100 - My Architecture Journey: Lessons Learned (November 9, 2020)
- Lesson 99 - Enterprise Architecture Roadmaps: Priority Model (October 26, 2020)
- Lesson 98 - Enterprise Architecture Roadmaps: Portfolio Model (October 12, 2020)
- Lesson 97 - Enterprise Architecture Roadmaps: Iteration Model (September 28, 2020)
- Lesson 96 - Enterprise Architecture Roadmaps: Introduction (September 14, 2020)
- Lesson 95 - Guidelines for Architecture Diagrams Revisited (August 31, 2020)
- Lesson 94 - Guidelines for Architecture Diagrams (August 3, 2020)
- Lesson 93 - What is Software Architecture? (July 20, 2020)
- Lesson 92 - Understanding Hybrid Architectures (July 6, 2020)
- Lesson 91 - Becoming A Software Architect (Part 6) (June 22, 2020)
- Lesson 90 - Becoming A Software Architect (Part 5) (June 15, 2020)
- Lesson 89 - Becoming A Software Architect (Part 4) (June 8, 2020)
- Lesson 88 - Becoming A Software Architect (Part 3) (June 1, 2020)
- Lesson 87 - Becoming A Software Architect (Part 2) (May 25, 2020)
- Lesson 86 - Becoming A Software Architect (Part 1) (May 18, 2020)
- Lesson 85 - Defining Scalability and Elasticity (May 4, 2020)
- Lesson 84 - Defining Deployability (April 20, 2020)
- Lesson 83 - Defining Performance and Responsiveness (April 6, 2020)
- Lesson 82 - Defining Testability (March 23, 2020)
- Lesson 81 - Workflow Event Pattern (March 9, 2020)
- Lesson 80 - Choosing the Right Caching Topology(February 24, 2020)
- Lesson 79 - Caching Topologies: Near Cache Hybrid(February 10, 2020)
- Lesson 78 - Caching Topologies: Replicated Cache(January 27, 2020)
- Lesson 77 - Caching Topologies: Distributed Cache (January 13, 2020)
- Lesson 76 - Caching Topologies: Single In-Memory Data Grid (December 30, 2019)
- Lesson 75 - Microservices Data Services (December 16, 2019)
- Lesson 74 - Elephant Migration AntiPattern (December 2, 2019)
- Lesson 73 - Architecture Fitness Functions (November 18, 2019)
- Lesson 72 - Multi-Broker Pattern (November 4, 2019)
- Lesson 71 - Measuring Scalability (October 21, 2019)
- Lesson 70 - Preventing Data Loss When Using Messaging (October 7, 2019)
- Lesson 69 - The Importance of Event-Driven Architecture (September 23, 2019)
- Lesson 68 - Automating Architectural Governance (September 9, 2019)
- Lesson 67 - Enterprise Architecture Strategy Case Studies (August 26, 2019)
- Lesson 66 - The Durable Interface Strategy of Enterprise Architecture (August 12, 2019)
- Lesson 65 - The Distributed Strategy of Enterprise Architecture (July 29, 2019)
- Lesson 64 - The Classic Alternatives Strategy of Enterprise Architecture (July 15, 2019)
- Lesson 63 - The Prescriptive Strategy of Enterprise Architecture (July 1, 2019)
- Lesson 62 - Enterprise Architecture Strategies (June 17, 2019)
- Lesson 61 - Extensibility Using Pub/Sub Messaging (June 3, 2019)
- Lesson 60 - Microservices and gRPC (May 20, 2019)
- Lesson 59 - The Tradeoffs of Loose Coupling (May 6, 2019)
- Lesson 58 - Architecture Certification (April 22, 2019)
- Lesson 57 - Loose Coupling and the Law of Demeter (April 15, 2019)
- Lesson 56 - The Ambulance Pattern (April 8, 2019)
- Lesson 55 - Architecture Decision Records (April 1, 2019)
- Lesson 54 - The Software Architects Bookshelf (March 25, 2019)
- Lesson 53 - Distributed Transactions Using Sagas (March 18, 2019)
- Lesson 52 - Modern Approaches to Enterprise Architecture (March 11, 2019)
- Lesson 51 - Initiative-Driven Approach to EA (March 4, 2019)
- Lesson 50 - Model-Driven Approach to EA (February 25, 2019)
- Lesson 49 - What is Enterprise Architecture? (February 18, 2019)
- Lesson 48 - Thread Delegate Pattern (February 11, 2019)
- Lesson 47 - Channel Monitoring Pattern (February 4, 2019)
- Lesson 46 - Reactive Architecture Patterns Introduction (January 28, 2019)
- Lesson 45 - Microservices Gateway Pattern (January 21, 2019)
- Lesson 44 - Microservices Aggregation Pattern (January 14, 2019)
- Lesson 43 - Microservices Orchestration Pattern (January 7, 2019)
- Lesson 42 - Deferred Data Migration (November 19, 2018)
- Lesson 41 - Microservices Contract Versioning (November 12, 2018)
- Lesson 40 - Common Integration Patterns (November 5, 2018)
- Lesson 39 - Integration Hubs (ESBs) (October 29, 2018)
- Lesson 38 - Identifying Microservices (October 22, 2018)
- Lesson 37 - Translating Quality Attributes to Business Concerns (October 15, 2018)
- Lesson 36 - Embedded Messaging (October 8, 2018)
- Lesson 35 - Watch Notification Pattern (October 1, 2018)
- Lesson 34 - Creating Service Domains (September 24, 2018)
- Lesson 33 - Creating a Service Taxonomy (September 17, 2018)
- Lesson 32 - Diagramming Architecture (September 10, 2018)
- Lesson 31 - Presenting Software Architecture (August 20, 2018)
- Lesson 30 - Agile and Software Architecture (August 13, 2018)
- Lesson 29 - Component and Service Coupling (August 6, 2018)
- Lesson 28 - Service Design Patterns (July 30, 2018)
- Lesson 27 - Circuit Breaker Pattern (July 23, 2018)
- Lesson 26 - Agile Architecture Review Boards (July 16, 2018)
- Lesson 25 - Architectural Abstraction (July 9, 2018)
- Lesson 24 - Lean Modeling Concepts (July 2, 2018)
- Lesson 23 - Orchestration vs. Choreography (June 25, 2018)
- Lesson 22 - Integration Architecture: Messaging (June 18, 2018)
- Lesson 21 - Integration Architecture: Remote Procedure Invocation (June 11, 2018)
- Lesson 20 - Integration Architecture: Shared Database (June 4, 2018)
- Lesson 19 - Integration Architecture: File Transfer (May 28, 2018)
- Lesson 18 - The Fallacies of Distributed Computing (May 21, 2018)
- Lesson 17 - Architecture Tradeoffs (May 14, 2018)
- Lesson 16 - The Challenges of Architecture Teams (May 7, 2018)
- Lesson 15 - Refactoring: Business Justification (April 30, 2018)
- Lesson 14 - Refactoring Patterns: Migration vs. Adaptation (April 23, 2018)
- Lesson 13 - Microservices and Reporting (April 16, 2018)
- Lesson 12 - CQRS and Microservices (April 9, 2018)
- Lesson 11 - Analyzing Architecture: Code Metrics (April 2, 2018)
- Lesson 10 - Analyzing Architecture: Microservices (Mar 26, 2018)
- Lesson 9 - Analyzing Architecture: Macro Techniques (Mar 19, 2018)
- Lesson 8 - Analyzing Architecture: Components (Mar 12, 2018)
- Lesson 7 - Analyzing Architecture: Structural Decay (Mar 5, 2018)
- Lesson 6 - Classifying Architecture Patterns (Feb 26, 2018)
- Lesson 5 - Microservices: Reducing Staging Iterations (Feb 19, 2018)
- Lesson 4 - Microservices: Distributed Logging (Feb 12, 2018)
- Lesson 3 - Soft Skills: Gaining Technical Breadth (Feb 5, 2018)
- Lesson 2 - How Kafka Differs From Standard Messaging (Jan 29, 2018)
- Lesson 1 - Event-Driven Architecture: Request/Reply Processing (Jan 22, 2018)