In 2022, we kicked off an internal Itenium learning series focused on architecture: over 20 sessions, each with a different angle, a combination of theoretical and hands-on, immediately useful in day-to-day project work. From different architectural styles to Design Patterns and Garbage Collection to git and CI, a wide range of topics for a very broad track — slides, real examples, demos, code-shows, and practical takeaways.
Kickoff
The session that frames the whole track. Before any single style, the foundations: what is a software architect, what separates good architecture from cargo-culted layers, and the mental tools to tell the difference.
The skills the job really demands are as much technical as they are communication. And at the heart of it all, non-functional requirements drive architecture, which cannot all be maximised, the”-ilities” trade-off. The ones your project needs decide its shape.
And — increasingly important in the AI era — how to make them enforceable: fitness functions like ArchUnit and NetArchTest turn your architectural rules into failing builds, something an agent can’t argue its way around the way it can reinterpret a written guideline.
We close with “thinking like an architect” which includes topics like trade-offs over best practices, accidental vs essential complexity, fitness functions and architecture decision records (ADR).
What we covered
- The different kinds of architects
- How non-functional requirements drive architecture
- SOLID vs KISS/DRY/YAGNI
- Common pitfalls to avoid
- How to think like an architect
Architectural Styles
The core catalogue, taught as trade-offs rather than fashion. n-tier, Onion & Hexagonal (ports and adapters), Event-Driven, Event Sourcing & CQRS, MicroServices, Space-Based, Microkernel, Broker, and Serverless. For each: what it optimises for, what is costs you, and – the part most courses skip – when it’s the wrong choice.
- n-tier — familiar and clearly layered, but scales as one lump.
- Onion & Hexagonal — domain isolated from infrastructure for testability; more ceremony up front.
- Event Sourcing & CQRS — full history and audit, reads scale apart from writes; steep curve.
- MicroServices — independent deploy and team autonomy, paid for with the distributed-systems tax.
Depending on the complexity of the architecture a session is between 30 minutes and 2.5 hours. Smaller architectures are often combined together.
Beyond the diagram – the architect’s broader remit
Good architecture isn’t only boxes and arrows. The architect guards the engineering practices that decide whether a system stays healthy long after the diagram is drawn. These modules round out the track with the unglamorous essentials.
Source Control
A clean, readable history is an architectural asset — one the architect should guard, along with the branching strategy. We offer four distinct git courses:
- Essentials — how git actually works under the hood
- Messes Recovery — how to recover when the team (or a colleague) has tied itself in knots
- Deep Dive — configuration, aliases, tools, hooks, secrets & more, including “git worktree” (newly essential in the age of AI)
- Modern Git — switch, restore, maintenance… wait, what?
Testing & Quality
Testing is an architectural concern, not an afterthought — and often the architect is the one who has to introduce it. Assessing a team’s test maturity coaching others toward it, and owning the test setup that’s genuinely hard: contract testing , end-to-end, testing across microservices, and spinning up real dependencies with Testcontainers. Pairs directly with our Testing Track.
The other parts
“If all you have is a hammer, everything looks like a nail.* An architect needs range, so the track also dips into the cross-cutting topics that quietly shape a system. A selection of our other architecture track sessions: REST & API design, CI/CD, SQL & query performance, Docker & Compose, Kubernetes, profiling & garbage collection, and even Regex. None of them are “architecture” on a slide; all of them land on the architect’s desk.
What we covered
- Source Control & Git Hygiene
- Testing & Quality is the architects responsibility
- The other parts: API Design, CI/CD, SQL, GC, Regex, …
Why this track works
Interested in running the Architecture Track for your team?
We tailor this track to your domain, your constraints, and your team’s level – from a single module to the full curriculum, on-site or remote.
Discover more events
Arrow Tag
We kicked off the season with Arrow Tag in Aalst: quick reflexes, smart tactics, and just the right amount of chaos.
