Simon Brown

Software development has changed immeasurably since the creation of the agile manifesto, but attempts to optimise team performance will still fail if good engineering fundamentals are not in place. I've had the privilege of visiting hundreds of organisations over the past 15+ years, spanning almost every industry sector, in almost 40 countries. From startups and small country specific businesses, to scale-ups and global household names. Despite the huge leaps made in the industry, a number of recurring themes have emerged from my conversations with the engineering managers, CTOs, directors of architecture, etc I've met:

• We don't have a standard way to discuss our products from an engineering perspective.
• Our lack of documentation is slowing us down.
• It takes too long for new hires to be effective.
• We still have a gap between dev and ops because they are speaking different languages.
• Our product owners, testers, and domain experts don't fully understand what the engineers are building.
• Our teams are autonomous and decentralised, but we're missing the big picture.
• Our engineering teams are not considering the trade-offs of the decisions they are making.
• We want to create an "architecture school" as a way to grow our engineers into tech leads/architects.

Speaking

I speak at software development conferences, meetups and organisations around the world; delivering keynotes, presentations, training courses and workshops. In 2013, I won the IEEE Software sponsored SATURN 2013 "Architecture in Practice" Presentation Award for my presentation about the conflict between agile and architecture. Many of the conference talks that I've presented can be found on YouTube.

Although most of the work that I do is on-site with organisations, I do speak at a number of public events. Here is my recent and future public speaking schedule:

Workshops

I offer the following workshops related to software architecture and the C4 model:

1. Visualising software architecture with the C4 model (a 1-day hands-on software architecture diagramming workshop)
2. Software architecture for developers (a 2-day introduction to software architecture, aimed at developers/engineers)

My workshops are typically run privately for your team/organisation at your own offices, but I occasionally run public (open enrolment) workshops via training providers or conferences. See Speaking - 2026 for a list of upcoming public events.

• Workshops are in-person only (no remote workshops or remote attendance).
• Pricing is a flat fee based upon location, inclusive of my travel and accommodation.
• Class size limit is 30 people (except workshop 1, option B).
• Prerequisites:
  • A room with a projector/large TV that I can connect my laptop to.
  • A room layout that enables groups of 2-4 people to work together for the hands-on exercises.
  • Some whiteboards/flip chart paper and marker pens for the hands-on exercises.
  • No laptops are required.
  • A typical workshop is 9am-5pm, but the timings are flexible.
  • Shorter duration versions of the workshops can be delivered if required.

1. Visualising software architecture with the C4 model (1 day)

This hands-on 1-day workshop focusses on the visualisation and communication of software architecture using the C4 model, providing some pragmatic, practical, and lightweight techniques that you can apply to your work the very next day. You'll learn why most software architecture diagrams are meaningless, how to critique them, how to fix them, and how to use the C4 model to create a simple yet powerful set of developer-friendly diagrams to describe software architecture.

There are two options for this workshop:

• Option A: Attendees will be asked to design a software solution for my “Financial Risk System” architecture kata, and to draw diagrams to describe that solution. This tends to be the best/quickest way to teach the C4 model concepts. The class size limit is 30 people.
• Option B: Attendees will be asked to draw diagrams to describe the software systems they are working on. The benefit of this approach is discussion of how to use the C4 model to describe your own software systems, and you will get some real-world software architecture diagrams of your own software systems at the end of the day. The class size limit is 20 people.



Abstract

It's very likely that the majority of the software architecture diagrams you've seen are a confused mess of boxes and lines. Following the publication of the Manifesto for Agile Software Development in 2001, teams have abandoned UML, discarded the concept of modelling, and instead place a heavy reliance on conversations centered around incoherent whiteboard diagrams or shallow "Marketecture" diagrams created with Visio. Moving fast and being agile requires good communication, yet software development teams struggle with this fundamental skill. A good set of software architecture diagrams are priceless for aligning a team around a shared vision, and for getting new-joiners productive fast.

This hands-on workshop explores the visual communication of software architecture, and is based upon years of experience working with software development teams large and small across the globe. We'll look at what is commonplace today, the importance of creating a shared vocabulary, diagram notation, and the value of creating a lightweight model to describe your software system. The workshop is based upon the "C4 model", which I created as a way to help software development teams describe and communicate software architecture, both during up-front design sessions and when retrospectively documenting an existing codebase. It's a way to create maps of your code, at various levels of detail. Static structure, runtime and deployment diagrams are all covered, so you'll be able to tell different stories to different audiences.

Agenda

• [09:00 - 09:15] Introduction
• [09:15 - 10:15] Software diagramming exercise 1
• [10:15 - 10:45] Review and feedback
• [10:45 - 11:00] Break
• [11:00 - 11:30] Diagramming anti-patterns and typical problems
• [11:30 - 12:00] Abstractions and creating a shared vocabulary
• [12:00 - 13:00] Lunch
• [13:00 - 14:30] C4 model - core diagrams
  • An overview of the C4 model
  • System Context diagrams
  • Container diagrams
  • Component diagrams
  • Notation and tips for better diagrams
  • FAQ part 1 (additional abstractions, message-driven architectures, microservices, etc)
• [14:30 - 14:45] Break
• [14:45 - 16:00] Software diagramming exercise 2
• [16:00 - 16:15] Review and feedback
• [16:15 - 16:45] C4 model - supplementary diagrams
  • System Landscape diagrams
  • Dynamic diagrams
  • Deployment diagrams
  • FAQ part 2 (C4 at scale, etc)
• [16:45 - 17:00] Discussion, questions, tooling, wrap-up



2. Software architecture for developers (2 days)

This 2-day workshop will give you an introduction to a pragmatic and practical approach to software architecture; including technical leadership, communication and how to balance up front design with agile approaches.

Day 1

• [09:00 - 09:15] Introduction
• [09:15 - 09:45] Architecture
  • What is software architecture?
  • Architecture vs design
  • The importance of software architecture
• [09:45 - 10:15] Architectural drivers
  • Requirements
  • Quality attributes
  • Constraints
  • Principles
  • Agility
• [10:15 - 10:45] Morning break
• [10:45 - 12:30] Software design exercise
  • Software design exercise
  • Design exercise review #1
• [12:30 - 13:30] Lunch
• [13:30 - 14:30] Architects
  • A definition of the software architecture role
  • Technical leadership and the different leadership styles
  • Technical skills
  • Soft skills
  • Software architecture and coding
• [14:30 - 15:00] Afternoon break
• [15:00 - 16:15] Visualising software architecture
  • Design exercise review #2
  • Diagramming anti-patterns and typical problems
  • The "model-code gap"
• [16:15 - 16:30] Discussion, questions and wrap-up

Day 2

• [09:00 - 10:15] C4 model - core diagrams
  • Abstractions and creating a shared vocabulary with a ubiquitous language
  • An overview of the C4 model
  • Notation and tips for better diagrams
  • System Context diagrams
  • Container diagrams
  • Component diagrams
• [10:15 - 10:45] Morning break
• [10:45 - 12:30] Software design exercise
  • Software design exercise
  • Design exercise review #3
• [12:30 - 13:30] Lunch
• [13:30 - 14:00] C4 model - supplementary diagrams
  • C4 and UML
  • System Landscape diagrams
  • Dynamic diagrams
  • Deployment diagrams
  • Frequently asked questions
• [14:00 - 14:30] Documenting software architecture
  • The importance of documentation
  • Writing lightweight supplementary documentation using a "software guidebook" or arc42
  • Architecture decision records
• [14:30 - 15:00] Afternoon break
• [15:00 - 15:30] Tooling
  • Diagrams vs models
  • Extracting software architecture information from code and "architecturally-evident coding styles"
• [15:30 - 16:15] Software architecture in the delivery process
  • Quantifying and prioritising risk
  • Identifying risk with risk-storming
  • Design exercise review #4
  • Waterfall, RUP, agile, etc
  • The conflict between architecture and agile
  • Approaching software architecture in a pragmatic, lightweight way
  • How much up front design is enough?
• [16:15 - 16:30] Discussion, questions and wrap-up

Writing

I've authored and contributed content to a number of books, as well as being a technical reviewer on others. I've also written articles for sites such as InfoQ.

Articles, interviews, and podcasts

Resources