Team Topologies: Organizing Business and Technology Teams for Fast Flow Paperback – Illustrated, September 17, 2019

You ship your org chart. Therefore, to fix shipping, fix your org first. This is often called the "Inverse Conway maneuver". Or, more verbosely, something like - "developing software is a socio-technical complex problem. We often naively focus on the technical part and only reactively look into the org part much later in the process. This should be turned around. Start with building the right org. In fact, the right org should be the very FIRST deliverable of a system architecture." All good, except there is no existing framework, empirical literature or large-scale study of "technical org design". That results in biased, reactive and unnecessarily nested, if not random, engineering orgs. To try to produce what we ought to, we lean into what we had in the past. That primarily results in huge communication overhead.This book methodically shows how to think and act on org design. It lays out four primary org types - value stream- (say, feature teams), enabling-, 'Complicated Subsystem- (say, databases or network), and Platform teams. It also shares three interaction modes these teams could work with each other - Collaboration, X-as-a-service and Facilitating. The 4x3 framework itself is a very powerful outcome from this. It also offers deep insights into composing, evolving and improving teams, and therefore the outcome of engineering orgs. Some key takeaways --- Treat people & technology as a single carbon/silicon system.-- Hallmark of good org design is where the communication pathways converge with the org chart. Org-charts are top-down constructs, most human communication at the workplace is "lateral" - with their peers. Pay attention to this when taking an org chart driven decision,-- When a team's "cognitive capacity" is exceeded, the team becomes a delivery bottleneck.-- Conway's big idea really was this question - "Is there a better design that is not available to us because of our org?" An org has a better chance of success if it is reflectively designed.-- Orgs arranged in "functional silos" (e.g., QA, DBA, Security) is unlikely to produce well architected end-to-end flow.-- "Team assignments are the first draft of the architecture".-- "Real gains in performance can often be achieved by adopting designs that adhere to a dis-aggregated model".-- High performing teams, by definition, are long lived. Regular reorg for "management reasons" should be a thing of the past.-- Single team is typically upper bounded at a size of 15 people. That is the ceiling of people with whom "we can experience deep trust".-- Three types of cognitive load - Intrinsic, Extraneous and Germane. Germane is more domain specific - where value is added. Our goal therefore is to eliminate "extraneous cognitive load", e.g., worry-free, reliable build with automated tests should be a promise fulfilled.-- Rather than choosing the architecture structure (e.g., monolith etc), therefore a leader's objective function should be to manage the cognitive load of every team to achieve safe and rapid software delivery.-- High trust team management is essentially "eyes on, hands off".-- SRE teams are not essential, they are optional. The single most important "business metric" for SREs is "error budget".-- Designing platform team(s) is one of the hardest decisions. Left to engineers alone, Platform will be overbuilt. A 2x2 framework -- "Engineering Maturity" (High-Low) vs. "Org Size or Software Scale" (High-Low) is a good conceptual model to choose the right platform team model. e.g., for highly matured teams operating at a lower scale/size, individual teams could subsume platforms with right collaboration. Less matured orgs at a large size should lean toward the "Platform-as-a-service" model.-- 3 different dependencies between teams - Knowledge, Task and Resource.-- Only around 1-in-7 to 1-in-10 teams should be "non-stream aligned", i.e., one of the other three types - Platform, Complicated Sub-system or Enabling teams.-- "When code doesn't work...the problem starts in how teams are organized and how people interact."-- While we intuitively think of monolith as the "codebase", this mental model can be expanded. Monolithic Builds (when there is ONE giant CI, even with smaller services); Monolithic Releases (when different services still rely on one shared env for testing, say); Monolithic Standards (e.g., tight governance of tool/language/framework); Monolithic Workplace (e.g., Open-plan office).-- "Fracture Plane" (aka seam) is a good metaphorical framework to think about "how to divide teams". Such planes can be thought of from "bounded context" (i.e., business domain); Regulatory Compliance (e.g., PCI DSS/Payments); Change Cadence (e.g., annual tax vs. accounting modules); Risk (e.g., money movement, loan vs. dashboards); Performance (e.g., highly sensitive components vs. others); Technology (e.g., Rust, Golang etc); Geography (e.g., offshore vs. HQ etc). Traditionally, and unfortunately, we divide teams more on technology than on other, often more powerfully valid, dimensions.-- "If you have microservices but you wait and do end-to-end testing of a combination of them before a release, you have a distributed monolith".-- Intermittent collaboration is better than constant interaction. Collaboration leads to innovation, so do not suppress all human-to-human collaboration in naturally aligned teams, but pay careful attention to whether communication cost far exceeds collaborative benefits. Collaboration tax is worth it if the org wants to innovate very rapidly. Increased collaboration != Increased communication.-- Interaction modes between teams should be habits, i.e., a targeted outcome of org design. This is essentially what Jeff Bezos' famous "Teams only interact with each other with API or please leave" memo does.-- Be alert for the white space between the roles, gaps that nobody feels responsible for.-- Biggest change in last decade -- historically, "develop" and "operate" were two distinct serialized phases with one way arrow from develop to operate. The best orgs have a tight feedback loop from operating back to develop. Customers know the best! The "operate" phase emanates "bottom-up" signals from customers via logs, metrics and other data that developing teams must pay equal - if not more - attention to as it does from other "top-down" directives (say, from PMs). These are essentially "synthetic sense organs for the outside".-- Software is less of a "product for" and more of an "ongoing conversation with" users. This, to respond to users, MUST be an integral part of the development team's responsibility. This should not be forked out to a separate, isolated "BAU or Service Maintenance team".Excellent book - must read if you are leading teams that are growing.

The book is a good product of the theories and have study cases, I like how the author put the problem and offered limited tooling to solve the problem....which actually helps with abstraction. The book implies many times that solution "depends" on many factor - that does not help much...even the author gives examples like "if...then". In general I enjoyed reading it.

In our ever-accelerating world, one of the fundamental qualities of a good system is its ability to change and adapt. This requirement applies both to companies wishing to keep pace with competitors as well as to the software supporting their business goals. Within the context of software systems, one of the best practices is to compose them of independent, goal-oriented components. If the architecture achieves the so-called “low coupling and high cohesion”, there is a good chance that new business requirements would result in quick changes in a single part of the system, as opposed to the lengthy, costly and error-prone releases which plague the mismanaged software. “Team Topologies” demonstrates that the pressure for adaptability should not only restructure the computer programs, but also - and maybe even more importantly - the IT departments creating them. In my opinion it is an excellent work showing that IT should be thought of holistically, not as separate parts of technical code and people’s organization.The basic premise of the book - that the structure of software reflects the organization building it - is not new. Known as the “Conway’s law”, the insight is over 50 years old. But I believe there weren’t too many titles so cogent in explaining its ramifications. In conscious embrace of Conway’s inevitability, the authors propose a toolkit of organizational building blocks - the eponymous team topologies - to use within software development structures. A team is meant to be “the smallest entity of delivery”; it is teams that build software, not individual engineers. Any team, to be valuable, should be long-lived, purposeful and autonomous. Under such conditions it is truly able to take ownership of the part of the system it develops, to build knowledge and to work with a minimized risk of errors.There are four proposed team types. Most engineers should be expected to work within “stream-aligned” teams, focused on delivering value for the customers. Other teams take a more supportive role - delivering platforms for developers, building complicated subsystems which require specialized knowledge, or enabling stream-aligned teams to gather new skills and practices. Team structures can be nested e.g. a platform can be internally developed by its own stream-aligned teams. In addition to team types, the book describes expected interactions between teams depending on their type and role in the project. In my opinion, Matthew Skelton and Manuel Pais make a compelling case that organizations applying the proposed approach - with team boundaries and responsibilities formed deliberately, which translates to proper boundaries and coupling within software components - can expect gains in the speed of delivery, as well as in software stability and employee morale.What is not stressed enough, in my opinion, is how difficult it is to design the aforementioned boundaries of responsibility of the team (and - by Conway’s law - of software built by it). From my experience it requires a deep knowledge of the business domain and is a daunting task for any large organization. The authors give a high-level overview of possible “fracture planes” (e.g. division by business domain, technology, customer type etc) but with only slight descriptions of how to find them precisely. In this regard, the book shows the end goal for how an IT organization should be structured without a detailed map on how to get there. It’s not a huge drawback, though, there is a lot of insights and knowledge to unravel nonetheless, I believe the book warrants multiple readings.I came to think that what “Team Topologies” propose is a convincing application of principles from agile and DevOps movements coupled with modern managerial practices, all while respecting Conway’s law. It is not a framework, though - I would rather call it a set of tools and insights to experiment with, regardless of any Named Frameworks™ your company might be using. All in all - I recommend this book to IT managers, architects, scrum masters and engineers interested in what happens outside of their teams. I guess it could be read by the business stakeholders as well, it is written in a way that won’t scare off non-technical people while giving insights on how IT could be more aligned with their needs. An instant classic if I ever saw one.