Chris Simon

Chris Simon

Startup CTO Coach

Sydney, Australia

Chris is a Startup CTO Coach helping startups realise their vision and new CTOs flourish in their roles. He also supports executives & boards with strategic technology advice, and engineering teams with training, mentoring and consulting in architecture, quality, domain-driven design and test driven development.

He is a regular meetup & conference speaker (NDC, KanDDDinsky, Serverless Days ANZ) and to support teams using Domain-Driven Design, he recently launched https://contextive.tech & co-founded the DDD Australia meetup.

He is the technical co-founder of https://www.inloop.com.au, home of Australian Fintech success stories https://www.flexischools.com.au and https://www.lanternpay.com (recently acquired by NAB).

Area of Expertise

  • Business & Management
  • Information & Communications Technology


  • Software Architecture
  • agile
  • Entrepreneurship
  • Distributed Software Systems
  • Technical Leadership
  • Domain Driven Design
  • Event Driven Architecture

TDD & DDD from the Ground Up

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!

Living Ubiquitous Language Documentation with Contextive

"A change in the language is a change in the model"

As you maintain model integrity you may end up with "duplicate concepts" or "false cognates".

Is everyone coding or are they coding? (Are you a doctor or a software developer)? Does a spoiler make you happy or sad (Are you a car enthusiast or a film lover?)

And how do new team members who weren't part of initial modelling exercises get up to speed on your ubiquitous language?

In this talk we'll explore a new open source tool called Contextive. It's designed for documenting the ubiquitous language and embeds the definitions in all the places the language is used - in code, documentation, online conversations and modelling tools.

It is context aware, so you always get the right definition in the right place.

And since you see the definitions where you're working in the domain, you can update them as soon as you identify need for change or improvements.

We'll explore how to use the tool including best practices, and benefits to be gained for new and old team members in capturing and evolving your language definition as part of your code repository.

DDD Explains: What are my stock options actually worth?

With the recent widespread layoffs in the technology sector, it's become more important than ever for developers to understand the financial realities behind the businesses we work for.

This talk will explore the fundamentals of corporate finance in terms developers will understand - by using Domain-Driven Design modelling techniques such as Event Storming and Domain Storytelling.

We'll start with the basics of business health - understanding profit & loss statements, balance sheets and cash-flow reports.

Then we'll look at how businesses are valued (privately and on the stock-market), and how that affects different funding and ownership models - for example angel investing, venture capital & private equity.

Building on this, we'll explore common long term incentive structures such as options and SAFE notes and how they can be impacted by preference shares.

At the end of this talk, you'll be well equipped to understand what the long term prospects of your future employers are and how to assess the potential risks and rewards of various compensation plans - and you might learn a bit about Domain-Driven Design along the way!

When Customers don't share a language: Modelling Deep Dive

In 2015 we launched an innovative new product into the Australian Fintech landscape - a healthcare & disability insurance claiming platform to simplify life for support providers, recipients and insurers.

It was intended that a heterogeneous group of support providers and insurers would engage with the platform - from doctors to physiotherapists to disability support workers on one side, and private insurers & state or federal government departments on the other.

Although the high level process for each of these groups was similar, the extant rules, terminology and UX scenarios varied.

In this talk, we'll do a deep dive of the modelling journey we went on, starting with aligning the model with our first customer, evolving it with our second, and radically reinventing it with our third.

We'll explore how the context map evolved from being aligned with user channels to being aligned with insurer subdomains and how we balanced the tradeoffs between specificity and genericness in the tactical pattern implementation within core domain contexts.

Experiences scaling a Modular Monolith to Microservices using the 4+1 Views

Over the last 7 years we used the 4+1 Views to design a system as a modular monolith - saving time, cost and complexity when the team was small & load was low and allowing simpler realignment of module boundaries as we were still discovering the domain. We gradually extracted modules into microservices as needed once we had built confidence in boundaries, when load grew and as the teams expanded and needed autonomy.

So how does it work?

The 4+1 views is a way of understanding systems that uses 5 different 'views' of the system, allowing to design and scale different aspects of the system in response to different triggers:

1. The logical view represents functional requirements & scales with functional complexity
2. The process view represents executable processes & how they interact & scales with concurrency and deployment requirements
3. The physical view represents the hardware & networks that the processes execute on & scales with load and throughput
4. The development view represents the system as seen by developers (e.g. code) & scales with the number of teams and team size
5. The scenarios view represents the various scenarios in which the system is used & highlights how components in the other views interact

A modular monolith is a system that has 'scaled up' the logical view (multiple modules), but not scaled up the process or physical views (single process, single hardware configuration).

In this talk we'll explore what went well, mistakes we made & tips for adopting this approach.

Winning at Continuous Deployment: The Art of Safe Contract Changes

You've done everything right: you have a continuous deployment pipeline, you have a commit stage with great unit tests, a pre-prod stage with fully automated deployment, robust end-to-end tests as well as some performance & security checks, and once all your quality gates are passed, your stream of changes march confidently towards production - but then somehow, someway, somewhy, production still blows up!

Continuous delivery is awesome, but the devil is in the details, and there's a decent chance you've been bitten by one of the biggest challenges - the safe management of contract changes.

Contracts can be obvious and public such as APIs (URL structure & schema), or obvious and private, such as database schemas, or non-obvious, such as the schema of in-flight messages in a queue, or dependency on specific timing expectations.

In this talk we'll work through the fundamental principle that underlies all safe contract changes - the 3 step model:

1. expand - introduce the change in a backwards and forwards compatible way
2. change - ensure all instances of the component and all dependants are using the new definition
3. contract - retire the obsolete compatibility elements

The good news is, with continuous delivery we can often do all three steps in quick succession! In this talk we'll:

* Explain the expand, change, contract model for contract changes
* Show examples of it in action for APIs, Message Queues, Database schemas (Relational and NoSQL)
* Share practical do's and don't's for applying the pattern in the real world

Domain Driven Design and Serverless: A Winning Combination

Domain Driven Design (DDD) is all about aligning software design with the business domain, helping developers build systems that accurately reflect real-world processes and requirements.

In this talk, we'll explore how to apply DDD patterns in a serverless context. Specifically, we'll look at mapping bounded contexts to serverless components, managing long running processes (aka sagas) and using serverless messaging capabilities for practical event-driven architecture, including a comparison between event streaming vs message queues for DDD-style business events.

Whether you're an experienced DDD practitioner or new to the concept, you'll walk away with valuable insights and strategies for building better software using these complementary approaches.

Learning to Love DDD - a Tale of Two Products

Over the last 16 years, I've been fortunate enough to launch two successful businesses as a hands-on CTO/co-founder & developer/architect.

The first, Flexischools, provides online services to schools & parent communities, and has supported millions of Australians over the years.

When we launched Flexischools, I was relatively inexperienced - I did my best to follow the guidance I could find online, but I frequently found myself struggling to incorporate the burgeoning growth in complexity of its feature-set into an increasingly tightly coupled code-base with a very small team of developers.

In 2015, I discovered DDD, and when reading the Blue Book, I felt a light bulb going off on every page. When we launched our second product, LanternPay, I vowed not to make the same mistakes.

LanternPay is a healthcare & disability claiming & payments platform supporting hundreds of thousands of Australian care providers and recipients to ensure prompt and equitable access to care.

In this talk, I'll reflect on the comparative experience of launching, operating & scaling both products and the impact DDD had on the technology & the business.

Some key questions we'll explore:

* How to use DDD when you're launching a new product into a new market and there are no domain experts to consult?
* Why it's not a good idea to use the same object/table to store both the size of a school uniform t-shirt and the presence of a slice of cheese on a sandwich
* How to make the business case for a major multi-service refactor when your DDD-inspired domain understanding evolves mid-project

KanDDDinsky 2023 Upcoming

October 2023 Berlin, Germany

.NET Day Switzerland 2023 Upcoming

August 2023 Zürich, Switzerland

Agile on the Beach Upcoming

Experiences scaling a Modular Monolith to Microservices using the 4+1 Views

July 2023 Falmouth, United Kingdom

Domain-Driven Design Europe 2023 Upcoming

June 2023 Amsterdam, Netherlands

Voxxed Days Brussels

Winning at Continuous Deployment: The Art of Safe Contract Changes

May 2023 Brussels, Belgium

ServerlessDays ANZ 2023

March 2023 Melbourne, Australia

KanDDDinsky 2022

October 2022 Berlin, Germany

NDC Oslo 2022

September 2022 Oslo, Norway

Chris Simon

Startup CTO Coach

Sydney, Australia