
Thinking Like a Software Architect
A Hands-On Guide to Modern Architecture Fundamentals, Delivery, and Engineering in PracticeBy Tamsin WhitlockLength14h 28m
About this audiobook
Architecture is the set of decisions you will regret slowly. This book teaches you to make them deliberately.
Most architecture books hand you a catalogue of patterns and leave you to guess which one fits. Thinking Like a Software Architect does the opposite. It gives you a repeatable way of reasoning: turn fuzzy requirements into measurable architecture characteristics, attach fitness functions that fail a build when the system drifts, and measure coupling instead of arguing about it. Components are derived from workflows and data ownership rather than from the org chart, so the boundaries you draw survive contact with real delivery pressure.
Style chapters score modular monoliths, service-based designs, microservices and event-driven topologies against the same criteria on one running system, so the comparison is real rather than rhetorical. From there the book follows the system into production: distributed data and eventual consistency, contracts that version safely, resilience through timeouts and circuit breakers, and the delivery machinery of pipelines, infrastructure as code, progressive deployment and observability. Every chapter ends with decisions you can apply to the system on your desk this week.
What you will learn
• Define what architecture is, when it matters, and when it is premature
• Translate quality attributes into measurable architecture characteristics and fitness functions
• Reason about modularity, coupling and connascence with evidence rather than opinion
• Identify and decompose components from workflows, data ownership and change patterns
• Compare monoliths, modular monoliths, layered, service-based, microservices and event-driven styles on one system
• Handle distributed data, transactions and eventual consistency without losing correctness
• Design integration contracts and API boundaries that version safely over time
• Add resilience, scaling and performance trade-offs with timeouts, circuit breakers and load strategies
• Build security architecture around explicit trust boundaries
• Take a system to production with pipelines, infrastructure as code, progressive deployment and observability
• Document decisions with views, diagrams and architecture decision records
• Apply Conway's Law deliberately and define the architect's role on a real team
Who it is for
This book is written for senior developers stepping into an architecture role and for practising architects who want sharper reasoning and fewer hand-wavy diagrams. It assumes you already write production code and are comfortable with services, databases and deployment pipelines. If you need to justify a design decision to engineers, product managers and operations teams at the same time, the frameworks here will help you do it with evidence.
Audiobook details
GenreTechnology
Length14 hrs 28 mins
Narrated byListen with 1,000+ voices
FormateBook with Audio
Publish dateSep 27, 2026
LanguageEnglish
Table of contents
1Thinking Like a Software Architect
2Foreword
3Preface
4About This Book
5Chapter 1: What Architecture Is and When It Matters
Show all chaptersShow less
61.1 Architecture as the Cost of Reversal
71.2 The Running System: Order Management at Meridian Supply
81.3 The Architect’s Remit and the Four Decisions
91.4 What Architecture Is Not
101.5 Stakeholders, Constraints and the Architecture Statement
111.6 How This Book Proceeds
12Chapter 2: Quality Attributes and Architecture Characteristics
132.1 From Vague Goals to Measurable Characteristics
142.2 Availability Arithmetic and the Cost of Nines
152.3 Latency Percentiles and Why Averages Lie
162.4 Fitness Functions: Making Characteristics Fail the Build
172.5 Trade-Offs, Priorities and the Characteristic Table
18Chapter 3: Modularity, Coupling and Connascence
193.1 Modules, Boundaries and Information Hiding
203.2 Afferent and Efferent Coupling, Instability and Abstractness
213.3 Connascence: Naming How Change Propagates
223.4 Measuring Coupling in a Real Codebase
233.5 Coupling, Cohesion and the Cost of Change
24Chapter 4: Component Identification and Decomposition
254.1 Workflow-First Decomposition
264.2 Data Ownership and the Write Rule
274.3 Granularity Drivers and Disintegration Pressures
284.4 Component Sizing and the Cost of a Boundary
294.5 Producing the Component Map
30Chapter 5: Monoliths, Modular Monoliths and Layered Styles
315.1 The Layered Style and Its Failure Modes
325.2 The Modular Monolith
335.3 Microkernel and Plugin Styles
345.4 Scoring the Monolith Family
35Chapter 6: Service-Based, Microservices and Event-Driven Styles
366.1 Service-Based Architecture
376.2 Microservices and True Data Ownership
386.3 Event-Driven Topologies: Brokers, Queues and Topics
396.4 Choreography, Orchestration and Workflow Ownership
406.5 Scoring the Service and Event Families
41Chapter 7: Distributed Data, Transactions and Consistency
427.1 Data Ownership, Replication and Read Models
437.2 Consistency Models and Eventual Consistency
447.3 Sagas and Compensation
457.4 Partition Trade-Offs and Availability Under Failure
46Chapter 8: Integration, Contracts and API Boundaries
478.1 Synchronous and Asynchronous Contracts
488.2 Versioning and Schema Evolution
498.3 Gateways, Routing and Boundary Responsibilities
508.4 Backpressure, Rate Limits and Flow Control