Maps of your code

The C4 model was 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, in the same way you would use something like Google Maps to zoom in and out of an area you are interested in.

Google Street View

Like source code, Google Street View provides a very low-level and accurate view of a location.

Google Maps

Navigating an unfamilar environment becomes easier if you zoom out though.

Google Maps

Zooming out further will provide additional context you might not have been aware of.

Google Maps

Different levels of zoom allow you to tell different stories to different audiences.

Abstractions

In order to create these maps of your code, we first need a common set of abstractions to create a ubiquitous language that we can use to describe the static structure of a software system. The C4 model considers the static structures of a software system in terms of containers, components and classes (or code). And people use the software systems that we build.

Abstractions

A software system is made up of one or more containers (web applications, mobile apps, desktop applications, databases, file systems, etc), each of which contains one or more components, which in turn are implemented by one or more classes (or code).

Person

However you think about your users (as actors, roles, personas, etc), people are the various human users of your software system.

Software System

A software system is the highest level of abstraction and describes something that delivers value to its users, whether they are human or not. This includes the software system you are modelling, and the other software systems upon which your software system depends (or vice versa).

Container

A container represents something that hosts code or data. A container is something that needs to be running in order for the overall software system to work. In real terms, a container is something like:

  • Server-side web application: A Java EE web application running on Apache Tomcat, an ASP.NET MVC application running on Microsoft IIS, a Ruby on Rails application running on WEBrick, a Node.js application, etc.
  • Client-side web application: A JavaScript application running in a web browser using Angular, Backbone.JS, jQuery, etc).
  • Client-side desktop application: A Windows desktop application written using WPF, an OS X desktop application written using Objective-C, a cross-platform desktop application written using JavaFX, etc.
  • Mobile app: An Apple iOS app, an Android app, a Microsoft Windows Phone app, etc.
  • Server-side console application: A standalone (e.g. "public static void main") application, a batch process, etc.
  • Microservice: A single microservice, hosted in anything from a traditional web server to something like Spring Boot, Dropwizard, etc.
  • Database: A schema or database in a relational database management system, document store, graph database, etc such as MySQL, Microsoft SQL Server, Oracle Database, MongoDB, Riak, Cassandra, Neo4j, etc.
  • Blob or content store: A blob store (e.g. Amazon S3, Microsoft Azure Blob Storage, etc) or content delivery network (e.g. Akamai, Amazon CloudFront, etc).
  • File system: A full local file system or a portion of a larger networked file system (e.g. SAN, NAS, etc).
  • Shell script: A single shell script written in Bash, etc.
  • etc

A container is essentially a context or boundary inside which some code is executed or some data is stored. And each container is a separately deployable thing.

Component

The word "component" is a hugely overloaded term in the software development industry, but in this context a component is simply a grouping of related functionality encapsulated behind a well-defined interface. If you're using a language like Java or C#, the simplest way to think of a component is that it's a collection of implementation classes behind an interface. Aspects such as how those components are packaged (e.g. one component vs many components per JAR file, DLL, shared library, etc) is a separate and orthogonal concern.

Core diagrams

Visualising this hierarchy of abstractions is then done by creating a collection of Context, Container, Component and (optionally) Class diagrams. This is where the C4 model gets its name from.

A System Context diagram

System Context diagram

A System Context diagram is a good starting point for diagramming and documenting a software system, allowing you to step back and see the big picture. Draw a diagram showing your system as a box in the centre, surrounded by its users and the other systems that it interacts with.

Detail isn't important here as this is your zoomed out view showing a big picture of the system landscape. The focus should be on people (actors, roles, personas, etc) and software systems rather than technologies, protocols and other low-level details. It's the sort of diagram that you could show to non-technical people.

Scope: A single software system.

Primary elements: The software system in scope.
Supporting elements: People and software systems directly connected to the software system in scope.

Intended audience: Technical and non-technical people, inside and outside of the immediate software development team.

A Container diagram

Container diagram

Once you understand how your system fits in to the overall IT environment, a really useful next step is to zoom-in to the system boundary with a Container diagram. A "container" is something like a web application, desktop application, mobile app, database, file system, etc. Essentially, a container is a separately deployable unit that executes code or stores data.

The Container diagram shows the high-level shape of the software architecture and how responsibilities are distributed across it. It also shows the major technology choices and how the containers communicate with one another. It's a simple, high-level technology focussed diagram that is useful for software developers and support/operations staff alike.

Scope: A single software system.

Primary elements: Containers within the software system in scope.
Supporting elements: People and software systems directly connected to the containers.

Intended audience: Technical people inside and outside of the immediate software development team; including everybody from software developers through to operations and support staff.

A Component diagram

Component diagram

Next you can zoom in and decompose each container further to identify the major structural building blocks and their interactions.

The Component diagram shows how a container is made up of a number of "components", what each of those components are, their responsibilities and the technology/implementation details.

Scope: A single container.

Primary elements: Components within the container in scope.
Supporting elements: Containers (within the software system in scope) plus people and software systems directly connected to the components.

Intended audience: Technical people within the software development team.

Supplementary diagrams

Once you have a good understanding of the static structure, you can supplement the C4 diagrams to show other aspects.

An Enterprise Context diagram

Enterprise Context diagram

The C4 model provides a static view of a single software system but, in the real-world, software systems never live in isolation. For this reason, and particularly if you are responsible for a collection of software systems, it's often useful to understand how all of these software systems fit together within the bounds of an enterprise. To do this, simply add another diagram that sits on top of the C4 diagrams, to show the enterprise context from an IT perspective. C4 therefore becomes C5, with this extra enterprise context diagram showing the organisational boundary, internal/external users and internal/external systems.

Essentially this is a high-level map of the software systems at the enterprise level, with a C4 drill-down for each software system of interest. From a practical perspective, an enterprise context diagram is really just a system context diagram without a specific focus on a particular software system.

A dynamic diagram

Dynamic diagram

A simple dynamic diagram can be useful when you want to show how elements in a static model collaborate at runtime to implement a user story, use case, feature, etc. This dynamic diagram is based upon a UML communication diagram (previously known as a "UML collaboration diagram"). It is similar to a UML sequence diagram although it allows a free-form arrangement of diagram elements with numbered interactions to indicate ordering.

A deployment diagram

Deployment diagram

A deployment diagram allows you to illustrate how containers in the static model are mapped to infrastructure. This deployment diagram is based upon a UML deployment diagram, although simplified slightly to show the mapping between containers and deployment nodes. A deployment node is something like physical infrastructure (e.g. a physical server or device), virtualised infrastructure (e.g. IaaS, PaaS, a virtual machine), containerised infrastructure (e.g. a Docker container), an execution environment (e.g. a database server, Java EE web/application server, Microsoft IIS), etc. Deployment nodes can be nested.

Notation

The C4 model doesn't prescribe any particular notation. Any notation used should be as self-describing as possible, with a diagram key/legend used to make the notation explicit. A simple notation that works well on whiteboards, paper, sticky notes, index cards and a variety of diagraming tools is as follows.

Person

Person

Software System

Software System

Container

Container

Component

Component

Relationship

Relationship

You can then use colour and shapes to supplement the diagram, either to add additional information or simply to make it more aesthetically pleasing.

C4 and UML

Although the example diagrams above are created using a "boxes and lines" notation, the core diagrams can be illustrated using UML with the appropriate use of packages, components and stereotypes. The resulting UML diagrams do tend to lack the same degree of descriptive text though.

A system context diagram
A container diagram
A component diagram
System Context diagram
Container diagram
Component diagram
A system context diagram
A container diagram
A component diagram

Metamodel

If you're interested in using the C4 model or building tooling to support it, here is some information about the basic metamodel.

Elements and relationships

Element type Parent Properties
Person None
  • Name*
  • Description
  • Location (Internal or External)
Software System None
  • Name*
  • Description
  • Location (Internal or External)
  • The set of containers that make up the software system
Container A software system
  • Name*
  • Description
  • Technology
  • The set of components within the container
Component A container
  • Name*
  • Description
  • Technology
  • The set of code elements (e.g. classes, interfaces, etc) that the component is implemented by
Code Element A component
  • Name*
  • Description
  • Fully qualified type
Relationship**
  • Description
  • Technology

* All elements in the model must have a name, and that name must be unique within the parent context.
** Relationships are permitted between any elements in the model, in either direction.

Views

View type Scope Permitted elements
1. System Context A software system.
  • Software systems
  • People
A System Context diagram
2. Container A software system
  • Software systems
  • People
  • Containers within the software system in scope
A Container diagram
3. Component A container
  • Software systems
  • People
  • Other containers within the parent software system of the container in scope
  • Components within the container in scope
A Component diagram
4. Code A component
  • Code elements (e.g. classes, interfaces, etc) that are used to implement the component in scope

Background and history

Creating software architecture diagrams is something of a lost art. Simon Brown has been running software architecture training courses for a number of years, part of which is a simple architecture kata where groups of people are asked to design a software solution and draw some architecture diagrams to describe it. Based upon the anecdotal evidence from training over 10,000 people in more than 25 countries, software architects and developers struggle with how to communicate software architecture. Even today, the majority of the diagrams from the initial iteration of the architecture kata are typically created using an ad hoc “boxes and lines” notation with no clear notation or semantics.

A software architecture sketch

A software architecture sketch

A software architecture sketch

A software architecture sketch

Frequently asked questions

C4 and microservices?

Broadly speaking, there are two options for diagramming microservices when using the C4 model.

  1. Microservices as software systems: If your software system has a dependency upon a number of microservices that are outside of your control (e.g. they are owned and/or operated by a separate team), model these microservices as external software systems that you can't see inside of.
  2. Microservices as containers: On the other hand, if the microservices are a part of a software system that you are building (i.e. you own them), model them as containers, along with any data stores that those microservices use. In the same way that a modular monolithic application is a container with a number of components running inside it, a microservice is simply a container with a (smaller) number of components running inside it.

Large and complex software sytems?

Even with a relatively small software system, it's tempting to try and include the entire story on a single diagram. For example, if you have a web application, it seems logical to create a single component diagram that shows all of the components that make up that web application. Unless your software system really is that small, you're likely to run out of room on the diagram canvas or find it difficult to discover a layout that isn't cluttered by a myriad of overlapping lines. Using a larger diagram canvas can sometimes help, but large diagrams are usually hard to interpret and comprehend because the cognitive load is too high. And if nobody understands the diagram, nobody is going to look at it.

Instead, don't be afraid to split that single complex diagram into a larger number of simpler diagrams, each with a specific focus around a business area, functional area, functional grouping, bounded context, use case, user interaction, feature set, etc. The key is to ensure that each of the separate diagrams tells a different part of the same overall story, at the same level of abstraction.

C4 and arc42?

The C4 model is compatible with the arc42 documentation template as follows.

  • Context and Scope => System Context diagram
  • Building Block View (level 1) => Container diagram
  • Building Block View (level 2) => Component diagram
  • Building Block View (level 3) => Class diagram

C4 vs UML, ArchiMate and SysML?

Although existing notations such as UML, ArchiMate and SysML already exist, many software development teams don't seem to use them. Often this is because teams don't know these notations well enough, perceive them to be too complicated, think they are not compatible with agile approaches or don't have the required tooling.

If you are already successfully using one of these notations to communicate software architecture and it's working, stick with it. If not, try the C4 model. And don't be afraid to supplement the C4 diagrams with UML state diagrams, timing diagrams, etc if you need to.

Change the terminology?

This terminology (context, containers, components and classes) works for many organisations and many types of software. However, sometimes an organisation will have an existing terminology that people are already familiar with. Or perhaps "components" and "classes" don't easily map on to the technology being used (e.g. functional languages often use the terms "module" and "function"). Feel free to modify the terminology that you use to describe software architecture at different levels of abstraction. Just make sure that everybody explicitly understands it.

More information

The following resources are recommended if you're looking for more information about visualising software architecture and the C4 model.

This is a recording of Simon Brown's talk at the OpenSlava conference in Bratislava, Slovakia during October 2017 (35 minutes).

This is a recording of Simon Brown's keynote at the Voxxed Days conference in Athens, Greece during May 2017 (60 minutes).

Software Architecture for Developers: Volumes 1 & 2

This is Simon Brown's Software Architecture for Developers (Volume 2) ebook, which is available to purchase from Leanpub as an ebook in PDF, EPUB and MOBI formats. It's a short guide to visualising, documenting and exploring your software architecture.

Simple Sketches for Diagramming Your Software Architecture

This is a short article written for Voxxed that summarises the C4 model.

A summary of the C4 model and tips for visualising software architecture

And here is a one-page cheat sheet (downloadable as an A3 poster in PDF format) that summarises how to visualise software architecture using the C4 model.

There are also some podcasts with Simon Brown, where he discusses the C4 model; including Software Engineering Daily and Software Engineering Radio.

Tooling

The following modelling and drawing tools can help create software architecture diagrams based upon the C4 model.

 

Structurizr

Structurizr

Structurizr is a collection of tooling to help you visualise, document and explore your software architecture. It's an implementation of the C4 model and allows you to create software architecture models using Java/C# and supplementary documentation using Markdown/AsciiDoc.

Structurizr Express

Structurizr Express

Structurizr Express lets you quickly create individual diagrams from the C4 model, using a JSON/YAML text format.

 

PlantUML

PlantUML

The open source Structurizr for Java and Structurizr for .NET libraries allow you to create a software architecture model and export it to the syntax used by PlantUML.

Graphviz

Graphviz

The open source Structurizr for Java library allows you to create a software architecture model and export it to the DOT syntax used by Graphviz.

DGML

DGML

When used in conjunction with the open source Structurizr for .NET library, Merijn de Jonge's Structurizr.Dgml project allows you to create zoomable/expandable diagrams with DGML (Directed Graph Markup Language), which is natively supported by Visual Studio.

 

Omnigraffle

OmniGraffle

Dennis Laumen has created a C4 stencil for OmniGraffle, that allows you to create diagrams using pre-built shapes.

draw.io

draw.io

Tobias Hochgürtel has created a C4 plugin for draw.io, that allows you to create diagrams using pre-built shapes.