It walks through replication, sharding, transactions, consistency and both batch and stream processing, with unusual honesty: nearly every chapter ends by explaining what still breaks after you have done it right. The second edition, now with Riccomini, reorganises the material and refreshes what a decade had made stale.
What I took from it
The distinction between the system that is the source of a piece of data and the systems holding derived copies of it. It is the rule I use most: before proposing an integration I draw where each field is born, because when two systems both believe they are the source, the problem does not get fixed by more synchronisation, it gets worse. A derived copy can be rebuilt, so it is allowed to be wrong for a while. A source is not.
The event log as a contract between systems. Instead of every application calling every other one, you publish what happened and each consumer builds the view it needs. It changes the conversation from "how many integrations do we need" to "which business facts should we publish", which is a far better question.
And the end-to-end argument: the guarantee has to live where the meaning lives. The identifier that stops the same invoice being paid twice has to come from the process, not from the network layer, no matter what the network layer promises.
What I left out
A sizeable share of the book covers problems that only appear at scales a mid-sized company will never reach: consensus between nodes, clocks that disagree, network partitions across data centres. It reads well as general culture, but presenting it as a live decision on a hundred-user project is selling someone a problem they do not have.