Skip to content
ballmüllersolutions logo Send an email Call us

K4 Architect

Shape systems and justify them: DDD, ports and adapters, CQRS and event sourcing, distributed systems with Orleans and Azure architecture.

Join the waiting list

Who it is for

For experienced developers who want to make and justify architecture decisions. A course makes nobody an architect – which is why this stage requires professional experience.

Prerequisites

K3 and at least a year of professional experience, or two years of professional experience and the placement test.

Afterward, you can

  • Make architecture decisions, weigh them and record them as ADRs
  • Shape systems into bounded contexts with domain-driven design
  • Keep domain rules in the domain model, with ports and adapters
  • Decide when CQRS and event sourcing pay off
  • Build and run distributed systems with Orleans
  • Secure consistency across system boundaries with outbox, inbox and idempotency
  • Design Azure architectures to the Well-Architected Framework, multi-tenant ones included
  • Build security and data protection into the architecture from the start
  • Compare code architecture styles and justify the one that fits
  • Weigh a modular monolith, microservices and virtual actors against each other
  • Design data for analytics with a warehouse and a lakehouse
  • Represent architecture in a team, estimate and explain it

Contents

  1. 4.1

    Architecture as a decision

    quality goals, trade-offs, architecture decision records (ADRs), the C4 model, costs (FinOps)

    20 h
  2. 4.2

    Strategic DDD

    domain, bounded contexts, context maps, event storming

    25 h
  3. 4.3

    Tactical DDD, ports and adapters

    aggregates, value objects, domain events, rules in the domain model, dependencies pointing inward, the modular monolith

    30 h
  4. 4.4

    CQRS and event sourcing

    when it pays off and when it does not, projections, versioning events

    25 h
  5. 4.5

    Distributed systems with Orleans

    virtual actors, the grain as an aggregate's consistency boundary, persistence and serialization with versioning, partitioning growing state, observers and streams, clusters in Container Apps

    40 h
  6. 4.6

    Integration and consistency

    outbox and inbox, process managers, idempotency, “at least once” delivery

    20 h
  7. 4.7

    Azure architecture

    the Well-Architected Framework, networking, identity, high availability and disaster recovery, multi-tenancy (an instance per customer or shared), governance

    30 h
  8. 4.8

    Security as architecture

    zero trust, threat modeling, data protection by design (GDPR), least privilege for identities

    20 h
  9. 4.10

    Code architecture: layers, onion, hexagonal, clean, vertical slice

    the same small feature built in each style, what each protects against and what it costs, architecture tests, how it relates to the ports and adapters of 4.3

    20 h
  10. 4.11

    Architecture styles and distributed systems in breadth

    layers, microservices versus a modular monolith, event-driven, serverless, SOA as history, CAP and PACELC, consistency models, cloud design patterns, micro-frontends, strangler fig and anti-corruption layer, fitness functions

    25 h
  11. 4.12

    Microservices in practice

    service boundaries, synchronous and asynchronous, data per service, sagas, an API gateway with YARP, Dapr on Container Apps, observability across services, microservices or Orleans

    25 h
  12. 4.13

    Data architecture

    OLTP and OLAP, data warehouse and lakehouse with Microsoft Fabric, ETL and ELT, Spark in overview

    20 h
  13. 4.14

    The architect in the team

    communication and stakeholders, estimating, presenting and defending decisions, mentoring, Scrum and Kanban, enterprise architecture with TOGAF and ArchiMate in overview

    15 h
  14. 4.9

    Final project

    the Kladde multi-tenant, with architecture documentation and an architecture review against a checklist

    30 h

About 345 hours in all (indicative).

Lessons

You see the text and video of every lesson here on the site after buying the course; the titles and goals are already shown. A self-study course: you work through the lessons in order and check your exercises yourself against the solutions.

You can read the first module (4.1) for free, with text and video, without signing in: so you see how the course works before you buy.

The lessons stand under their modules, in the order of the course. Click a module to open or close its lessons.

4.1 Architecture as a decision

Indicative: 20 hours · 5 lessonsfree to read
  1. Lesson 1 · about 180 minutes

    What architecture is

  2. Lesson 2 · about 240 minutes

    Quality goals

  3. Lesson 3 · about 240 minutes

    Trade-offs and ADRs

  4. Lesson 4 · about 240 minutes

    The C4 model

4.2 Strategic DDD

Indicative: 25 hours · 6 lessons
  1. Lesson 6 · about 240 minutes

    Understanding the domain

  2. Lesson 7 · about 300 minutes

    Event storming: the big picture

  3. Lesson 8 · about 240 minutes

    Event storming: processes in detail

  4. Lesson 9 · about 240 minutes

    Finding bounded contexts

  5. Lesson 10 · about 240 minutes

    Context maps

  6. Lesson 11 · about 120 minutes

    Who owns the data

4.3 Tactical DDD, ports and adapters

Indicative: 30 hours · 7 lessons
  1. Lesson 12 · about 240 minutes

    Entities and value objects

  2. Lesson 13 · about 300 minutes

    Aggregates and their boundaries

  3. Lesson 14 · about 240 minutes

    Rules belong in the domain model

  4. Lesson 15 · about 240 minutes

    Domain events

  5. Lesson 16 · about 240 minutes

    Ports and adapters

  6. Lesson 17 · about 240 minutes

    The modular monolith

  7. Lesson 18 · about 180 minutes

    Restructuring existing code

4.4 CQRS and event sourcing

Indicative: 25 hours · 6 lessons
  1. Lesson 19 · about 180 minutes

    When CQRS and event sourcing pay off

  2. Lesson 20 · about 180 minutes

    CQRS without event sourcing

  3. Lesson 21 · about 240 minutes

    An aggregate from events

  4. Lesson 22 · about 240 minutes

    An event store on SQL Server

  5. Lesson 23 · about 240 minutes

    Projections and read models

  6. Lesson 24 · about 240 minutes

    Versioning events

4.5 Distributed systems with Orleans

Indicative: 40 hours · 10 lessons
  1. Lesson 25 · about 240 minutes

    Virtual actors

  2. Lesson 27 · about 240 minutes

    Storing state

  3. Lesson 28 · about 240 minutes

    Serialization and versioning

  4. Lesson 29 · about 240 minutes

    Event sourcing in the grain

  5. Lesson 30 · about 240 minutes

    Partitioning growing state

  6. Lesson 31 · about 180 minutes

    Timers and reminders

  7. Lesson 32 · about 240 minutes

    Observers and streams

  8. Lesson 33 · about 180 minutes

    Testing Orleans

  9. Lesson 34 · about 180 minutes

    Clusters in Container Apps

4.6 Integration and consistency

Indicative: 20 hours · 5 lessons
  1. Lesson 35 · about 180 minutes

    “At least once” delivery

  2. Lesson 36 · about 240 minutes

    Outbox

  3. Lesson 37 · about 240 minutes

    Inbox and idempotent receivers

  4. Lesson 38 · about 240 minutes

    Process manager

  5. Lesson 39 · about 180 minutes

    Integration with the outside world

4.8 Security as architecture

Indicative: 20 hours · 5 lessons
  1. Lesson 40 · about 180 minutes

    Zero trust for architects

  2. Lesson 41 · about 240 minutes

    Threat modeling with STRIDE

  3. Lesson 42 · about 240 minutes

    Data protection by design

  4. Lesson 43 · about 180 minutes

    Deleting in a system that forgets nothing

  5. Lesson 44 · about 240 minutes

    Least privilege for identities

4.7 Azure architecture

Indicative: 30 hours · 8 lessons
  1. Lesson 45 · about 180 minutes

    The Well-Architected Framework

  2. Lesson 46 · about 240 minutes

    Networking

  3. Lesson 47 · about 180 minutes

    Identity: people, tenants, services

  4. Lesson 48 · about 180 minutes

    High availability

  5. Lesson 49 · about 240 minutes

    Disaster recovery: RTO, RPO and the drill

  6. Lesson 50 · about 300 minutes

    Multi-tenancy

  7. Lesson 51 · about 180 minutes

    Governance and cost

  8. Lesson 52 · about 120 minutes

    Matching AZ-305

4.10 Code architecture: layers, onion, hexagonal, clean, vertical slice

Indicative: 20 hours · 6 lessons
  1. Lesson 53 · about 180 minutes

    What code architecture protects against

  2. Lesson 54 · about 180 minutes

    Classic layers

  3. Lesson 55 · about 240 minutes

    Onion and clean architecture

  4. Lesson 56 · about 120 minutes

    Hexagonal compared

  5. Lesson 57 · about 240 minutes

    Vertical slice

  6. Lesson 58 · about 120 minutes

    Comparison, architecture tests and decision

4.11 Architecture styles and distributed systems in breadth

Indicative: 25 hours · 8 lessons
  1. Lesson 59 · about 180 minutes

    Architecture styles at a glance

  2. Lesson 60 · about 180 minutes

    Modular monolith versus microservices

  3. Lesson 61 · about 180 minutes

    Event-driven and serverless as architecture

  4. Lesson 62 · about 240 minutes

    CAP, PACELC and consistency models

  5. Lesson 63 · about 240 minutes

    Cloud design patterns

  6. Lesson 64 · about 180 minutes

    Replacing instead of rewriting

  7. Lesson 65 · about 120 minutes

    Micro-frontends in outline

4.12 Microservices in practice

Indicative: 25 hours · 8 lessons
  1. Lesson 67 · about 180 minutes

    Service boundaries

  2. Lesson 69 · about 180 minutes

    Data per service

  3. Lesson 70 · about 240 minutes

    Sagas across services

  4. Lesson 71 · about 180 minutes

    An API gateway with YARP

  5. Lesson 72 · about 240 minutes

    Dapr on Container Apps

  6. Lesson 73 · about 120 minutes

    Observing across services

  7. Lesson 74 · about 120 minutes

    Microservices or virtual actors?

4.13 Data architecture

Indicative: 20 hours · 5 lessons
  1. Lesson 75 · about 180 minutes

    OLTP and OLAP

  2. Lesson 77 · about 240 minutes

    ETL and ELT

  3. Lesson 78 · about 180 minutes

    Spark in overview

  4. Lesson 79 · about 240 minutes

    Data as an architecture decision

4.14 The architect in the team

Indicative: 15 hours · 6 lessons
  1. Lesson 80 · about 180 minutes

    Communicating and stakeholders

  2. Lesson 81 · about 180 minutes

    Estimating and dealing with uncertainty

  3. Lesson 82 · about 180 minutes

    Presenting and defending decisions

  4. Lesson 83 · about 120 minutes

    Mentoring and architecture reviews

  5. Lesson 84 · about 120 minutes

    Scrum and Kanban

  6. Lesson 85 · about 60 minutes

    Enterprise architecture in overview

4.9 Final project

Indicative: 30 hours · 7 lessons
  1. Lesson 86 · about 180 minutes

    Planning

  2. Lesson 87 · about 300 minutes

    Creating and dissolving tenants

  3. Lesson 88 · about 300 minutes

    Proving isolation

  4. Lesson 89 · about 300 minutes

    Delivering and operating

  5. Lesson 90 · about 300 minutes

    Architecture documentation

  6. Lesson 91 · about 180 minutes

    Architecture review

  7. Lesson 92 · about 240 minutes

    Architecture review with a checklist

Final project: the Kladde

What the Kladde can do after this course

Rebuilt into domain modules: quotes and appointments as aggregates in Orleans grains, the sales pipeline with event sourcing and read models, multi-tenant (an instance per customer or shared, justified in an architecture decision), with a C4 model and a cost calculation.

At the end you present your architecture and its documentation and check both against a checklist of the questions an architecture review asks – on your own or with colleagues.

More about the Kladde

Certifications

An offer, never a requirement: these Microsoft exams fit this stage. You take them at Microsoft; we are not a Microsoft training partner.

Keep learning with Microsoft Learn

Microsoft's learning paths and documentation that go with this course.

All courses at a glance