When launching a new product, startup or project, it is tempting to build systems in preparation for inevitable success and scale - technical, and socio-organisational.

But this frequently fosters premature complexity, such as a single team adopting microservices well before they would be useful.

Alternatively, starting simple and hoping you can evolve towards the right design leaves many teams with a tangled mess of technical debt and systems that have long outgrown their original intended use.

This masterclass guides how to manage complexity without sacrificing scalability by imagining the future but building for the now.

In this hands-on masterclass you'll get practical experience with a range of different techniques such as Event Storming, the C4 model, Team Interaction Modelling & User Story Mapping. You'll learn about Kruchten's 4+1 views and which techniques are useful in each view, and by considering the 4+1 views holistically, learn how to design more scalable & evolvable socio-technical systems.

Past Attendee Feedback

• "I understand how to describe a technical strategy more confidently and understand the different aspects of the system I'm working with"
• "I've already been practising and am working on applying the knowledge I have gained from this course, and it's like a light bulb has been switched on"
• "I almost wish I'd done this training earlier in my career - super helpful!"

Curriculum:

Day 1

• Introduction to Socio-technical Systems & 4+1 Views
• Logical View - Domain Modelling with Domain-Driven Design & Event Storming
• Process View (Part 1) - Microservices, Monoliths, Frontends & APIs in the C4 Model

Day 2

• Process View (Part 2) - Inter-process Communications - Logical vs Physical Communications, Queues vs Streams
• Physical View - Cloud Native Architectures
• Developer View - DDD & Team Topologies Interaction Modelling, Hexagonal Architecture & Vertical/Feature Slicing
• Scenario View - CI/CD, Observability & User Story Mapping

Are you interested in using Domain-Driven Design (DDD) to create maintainable and scalable software, but not sure how to get started? Or perhaps you've heard that DDD is only suitable for complex domains - and when starting out, you're not sure if your project will need it?

Join me for a live coding demonstration that will show you how to apply Test-Driven Development (TDD) from the very beginning of a project so you can bring DDD in when you need it.

We'll start with the simplest possible implementation - a basic CRUD system to help a university handle student enrolments. We'll gradually add more complex requirements, such as the need to ensure courses don't become over-enrolled - which will prompt us to do some code-smell refactoring, strangely enough arriving at things that start to look like the DDD tactical patterns of repositories, aggregates and domain services.

In implementing these requirements, inspiration will strike! What if the model were changed - what if we allowed all enrolments and then allocated resources to the most popular courses as required so we never have to prevent a student from enrolling? We'll now see how the TDD tests and the neatly refactored domain models make it much easier to embark on this dramatic change - in other words, how much more maintainable our DDD codebase has become.

The code in this demo is available in either C# or Java - the audience will vote on the day which language is used!