// why this exists
Most of what I have written about systems sits at altitude: scale, reliability, cost, the shape of a platform. This is the floor underneath it. It is the level an engineer actually works at on an ordinary Tuesday, and it is the level that decides whether the architecture above it survives contact with a deadline.
The vocabulary here is old on purpose. GoF, SOLID, KISS, DRY, the Enterprise Integration Patterns, domain-driven design. None of it is new, and that is exactly the argument: it has outlived every framework that promised to replace it. When a machine writes the first draft, the scarce skill stops being the typing and becomes the judgment about structure.
So this is not a pattern catalogue. Catalogues exist, they are free, and they will not make you better. Every piece here is one body of knowledge and one moment where knowing it, or not knowing it, changed how something turned out.
SkillSet
What you can do. The patterns, the principles, the practice. It is the part that can be taught, which is why it is the least interesting of the three and still has to be earned first.
MindSet
How you decide. Knowing a pattern is trivia until you know when not to reach for it. Judgment is what separates the two, and judgment is slower to build than vocabulary.
ValueSet
Why you bother. Nobody masters this material for a job title. You do it because leaving something better built than you found it is its own reason, and because someone will inherit your code.
The Guide
Much of this is already written and scattered across the library. The guide gathers it into an order that makes sense, and marks honestly what is still missing. Essays keep their original homes; this is a route through them, not a relocation. Parts I to V build the craft itself; Part VI walks the same craft through all nine phases of the lifecycle, and Part VII is how you prove any of it happened.
Part I · Why Mastery Still Pays
Deep Roots, Fresh Growth
The manifesto for the whole guide. Why you cannot question a pattern you never took the time to master.
Am I an Excellent Software Engineer?
The question that starts the whole pursuit, asked honestly.
Work Is Craft. Or It Is Nothing.
The ethic underneath everything else here.
Mastery Is a Moving Target
Apprentice, journeyman, master, held differently for every skill you own.
Your Code Is Your Character
Open code somebody else wrote and within minutes you know who they are.
Why Software Pays Well, and What It Actually Takes
The honest economics of the craft, and what the money is actually buying.
Knowledge Was Never the Commodity
The AI-era case for fundamentals: judgment was always the scarce part.
The Engineering Philosophy Behind Every Team I Have Built
The stated version of what the rest of this guide practises.
Part II · Principles
SOLID Is One Question, Not Five Rules
Everybody can name the five. Far fewer can say what they are all circling.
The Three Rules That Contradict Each Other
KISS, DRY and YAGNI, and what to do when following one breaks another.
Coupling and Cohesion Are the Only Two
The pair sitting underneath every principle anyone has ever named.
You Can't Fake Java
The language that exposes weak fundamentals, and six years of watching it happen.
Five Stepping Stones to Systems That Last
The principles that decide whether a system is still good in five years.
Fear Is the Real Technical Debt
The debt that never appears in the backlog, and what it actually costs.
Part III · Patterns
A Pattern Is a Shared Vocabulary, Not a Solution
The Gang of Four, read as language rather than as recipes.
The Cloud Pattern Catalogue
Retry, bulkhead, saga, CQRS, strangler fig, and the cost each one quietly adds.
Enterprise Integration Patterns
How systems talk when they cannot call each other directly.
Nobody Promised You 100% Uptime
Circuit breakers, chaos, and designing for failure instead of chasing a number.
Design for the Load You Have Not Met Yet
Throughput, load, capacity, scale, and the commitments that follow from them.
Every Platform Starts on One Server
Six decisions from one machine to reliable and fast, each solving the last one's failure.
Scale Is Not the Same Problem as Reliable
The edge, statelessness, geography, decoupling, and the database that finally splits.
Five Deployment Strategies. One Personal Favourite.
Canary, blue-green, and the rest, judged by what they cost on a bad day.
Good Swimmers Drown Quietly
Every resilience pattern is also a concealment pattern. What to measure instead.
The Planes That Didn't Come Back
Survivorship bias as a reasoning pattern, and where it hides in engineering.
Part IV · Design
The Words the Business Actually Uses
Domain-driven design, starting where it starts: the language, not the diagram.
Bounded Contexts Are Team Boundaries
The structural half of DDD, and why the org chart keeps winning.
Are You Ready for Microservices?
The readiness questions to answer before the split, not after.
Your API's Users Are Developers
The contract as a product, and the people who have to live inside it.
When Architecture Becomes a Leadership Problem
The point where the diagram stops being the hard part.
How Software Gets Built: A Field Guide to the Lifecycles
Waterfall to harness engineering, plus the thirty corrective years in between.
What Agents Actually Need
Domain-driven scoping applied to something that did not exist when DDD was written.
Part V · Practice
The Test You Write First Is a Design Document
Test-driven development read as design feedback rather than as coverage.
Code Smells Are Sentences, Not Crimes
Refactoring as reading. What the code is telling you before you change it.
300 Transactions Per Second, Then Silence
A performance investigation, told the way it actually unfolded.
The Black Box Mindset
What to do about the parts of the system you did not write and cannot see into.
Invert the Problem
Ask how to guarantee failure, then refuse to do any of it.
I Ran an A/B Test Instead of an Argument
Evidence as the cheapest way out of a disagreement nobody was winning.
Thirty Percent of the Code. Zero Percent of the Architecture.
What a machine writing the first draft does, and does not, change.
Part VI · Excellence Across the Nine Phases
Craft is not something that happens in the Develop phase and nowhere else. The same nine phases run under every methodology on this site, and excellence looks different in each one. This part walks all nine, including the ones nobody writes about.
01 · Analyze – The Requirement That Was Never a Requirement
Most defects are born here, long before anyone writes a line. Telling a need from a solution wearing a need's clothes.
02 · Design – The Review That Earns Its Hour
What has to be on the table before a design review is worth the salaries sitting around it.
03 · Develop – Code You Will Still Understand in a Year
The only readability standard that survives contact with a stranger, and that stranger is usually you.
04 · Test – Coverage Is Not Confidence
A hundred percent of the lines and none of the risk. What to measure instead of the percentage.
05 · Build – A Pipeline You Can Trust at Three in the Morning
Reproducibility, provenance, and the flaky build that quietly taught a team to ignore red.
06 · Deploy – Boring Is the Achievement
The goal was never a heroic release. It was a release nobody remembers the next morning.
07 · Monitor – You Cannot Operate What You Cannot See
Instrumentation as a design output rather than something bolted on after the first bad night.
08 · Deliver – Shipped Is Not Delivered
The phase almost nobody writes about. Value accepted by a real user is a different event from code in production.
09 · Change – The System That Survives Its Own Success
Versioning, rollback, and the discipline of changing something a lot of people now depend on.
Part VII · The Numbers That Decide
Excellence that cannot be measured is a matter of opinion, and opinions lose to deadlines. These are the numbers that turn a claim about quality into something a room can check.
SLI, SLO, SLA: Three Words, One Promise
The indicator you pick, the target you set, the contract you sign, and the error budget that makes the target real.
RTO and RPO: What You Are Allowed to Lose
How long you may be down, and how much data may vanish. Two numbers the business owns and engineering keeps guessing at.
The Five DORA Metrics, Read Honestly
Throughput and instability, why MTTR was renamed and narrowed in 2023, and what happens when a metric becomes a target.
Averages Lie. Percentiles Confess.
p50, p95, p99, and why the number your dashboard shows by default is the least useful one on it.
Precision Is Not the Point
The estimation toolkit behind every capacity number you will ever have to defend out loud.
A pattern you cannot question is a pattern you have not learned, only memorised. The point of all this old vocabulary was never to give you answers to reach for. It was to make you precise enough to disagree well, with other engineers and with yourself, about work that will outlive the framework it was written in.