Software Architecture: Principles, Patterns & Practice

For senior software engineers · half-day to multi-week · hands-on with your own project

The bridge from senior engineer to architect: from the values that drive good design to a real architectural decision on your own project.

You’re already a strong engineer. The next step, architecture, is usually learned the slow way: by shipping systems and finding out years later which decisions held. This workshop compresses that path. It teaches architecture as a discipline. What to value, which principles endure, where the patterns actually apply, and the working practices that keep an architecture honest over time. Then it puts you in the architect’s seat.

1. Foundations: the discipline

The values good architecture serves: fitness for purpose, simplicity, evolvability, and cost honesty. The principles that outlast any trend: separation of concerns, coupling and cohesion, designing for reversibility. The patterns (layered, modular monolith, microservices, event-driven) taught with their context: when each earns its cost, and when it doesn’t. And the practices of the working architect, held together by a five-step method for making one sound decision: Frame, Options, Size, Decide, Record.

2. Architecture in the working world: cases and craft

We study real case studies and the craft that surrounds a living system. How to document architecture so the reasoning survives, using ADRs (Architecture Decision Records, Michael Nygard’s practice of writing down why, not just what). Evolutionary architecture and fitness functions (Neal Ford and Rebecca Parsons’ idea of automated checks that guard the qualities you care about as the system changes). And how delivery metrics close the feedback loop on your decisions. Architecture is not a diagram you draw once. It is a set of decisions you maintain.

3. Your own project: judgement and kata

The hands-on stage. Architectural katas (small, timed design problems worked in groups, practice bouts for architects) build fluency. Then the real thing: you bring a live architectural decision from your own project, and we run it through the method together, coached. You leave having made a real decision, with the reasoning recorded.

Formats

One curriculum, three depths: a half-day briefing (foundations plus one worked case), a two-day hands-on (all three stages, katas included), or a multi-week cohort (a coached decision on your own system between sessions). Delivered online, in person, or hybrid.

Who it’s for

Senior software engineers ready to carry architectural responsibility. You design features and subsystems confidently, and you want to reason about whole systems the way an architect does. Especially valuable where AI and cloud choices are raising the cost of getting a design decision wrong.

You keep

The five-step method, the pattern-and-principle map with the contexts that make each apply, a working ADR habit, kata experience, and one real architectural decision from your own project: reasoned through, recorded, defensible in front of your team.

Patterns can be read. Principles can be memorized. Judgement, knowing which applies here, is built through decisions you own. This workshop teaches the first two properly and gives you supervised practice at the third, before the job demands it.