Security Architect: From Frameworks to Foundations

Under Security Brutalism, an architect designs around one habit, assuming every component will eventually be compromised and building the system so that assumption never turns into a disaster. Identity gets split narrowly instead of shared broadly across a service, network paths get segmented so a breach in one area can't walk straight into the next, and logging and recovery get built in from the start rather than bolted on once something has already gone wrong.

In practice, this means that if a design routes data through several extra services just to move it from one place to another, it gets cut down to fewer moving parts, since every additional service is one more thing that can be misconfigured or forgotten later. No control goes into production unless the team running it can say, in plain terms, what it stops and why it's there.

A small number of standards apply across every system without exception, covering identity, network boundaries, logging, and who signs off before a change reaches production, and teams build freely within those standards without renegotiating them on every new project.

When something breaks, the fix strengthens that shared baseline rather than patching just the one system that got hit, which is what makes the whole environment harder to break over time, not any single decision made along the way.