Demo Sign up Cloud service On-premises installation

The quickest way to create software architecture diagrams

Have you ever spent hours trying to make a software architecture diagram look pretty? It's 2019, and we shouldn't be using general purpose diagramming tools to create software architecture diagrams. We're supposed to be engineers, not artists! Structurizr is a lightweight, web-based modelling tool that lets you quickly create diagrams based upon the C4 model for software architecture.

System Landscape diagram

System Landscape diagrams

System Context diagram

System Context diagrams

Container diagram

Container diagrams

Component diagram

Component diagrams

Dynamic diagram

Dynamic diagrams

Deployment diagram

Deployment diagrams

Your software architecture documentation hub


Create software architecture diagrams based upon the C4 model with code via the web API, or by using the browser-based workspace editor.


Create supplementary documentation using Markdown or AsciiDoc, along with architecture decision records (ADRs) to capture your significant design decisions, all full-text searchable.


Explore your software architecture model from a number of perspectives, to get insight into the structure of your software.





Share your software architecture diagrams and documentation with your team, using role-based access or a unique sharing link.


Export your software architecture diagrams to PNG or SVG, via the UI or the scripting API. The complete set of diagrams and documentation can also be exported to a static HTML page for offline use.


Integrate your software architecture diagrams into websites and wikis, using the iframe embed or the macros built specifically for Atlassian Confluence. Search for content directly from Slack.

Option 1: Use code and the web API

The first option for creating software architecture models is to use the web API in conjunction with the Structurizr for Java and Structurizr for .NET client libraries, both of which are open source. For example, with Java:

public static void main(String[] args) throws Exception {
    Workspace workspace = new Workspace("Getting Started", "This is a model of my software system.");
    Model model = workspace.getModel();

    Person user = model.addPerson("User", "A user of my software system.");
    SoftwareSystem softwareSystem = model.addSoftwareSystem("Software System", "My software system.");
    user.uses(softwareSystem, "Uses");

    ViewSet viewSet = workspace.getViews();
    SystemContextView contextView = viewSet.createSystemContextView(softwareSystem, "SystemContext", "An example of a System Context diagram.");

    Styles styles = viewSet.getConfiguration().getStyles();

    StructurizrClient structurizrClient = new StructurizrClient("key", "secret");
    structurizrClient.putWorkspace(25441, workspace);

Here's the resulting diagram when you open it in Structurizr, where the layout of the diagrams can be modified.

A simple diagram
A simple diagram
A diagram key is automatically generated for you, based upon the styles and shapes defined in the model.

The code used to create the software architecture model can be thought of as an executable domain specific language, or an executable architecture description language. This offers a number of opportunities over using a static textual description, such as the ability to use the programming language's reflection and static analysis capabilities to find and extract components from the codebase being documented. The web API is open and documented too, providing you the ability to create your own tooling if desired.

Option 2: Use the browser-based workspace editor

The second option is to the browser-based workspace editor (demo) where you can create diagrams, along with supplementary documentation and decision records.

Structurizr's online editor

View and manage the hierarchy of elements that make up the static structure.

Structurizr's online editor

View and manage the relationships between elements in the model.

Structurizr's online editor

Modify the set of diagrams and their content.

Structurizr's online editor

Modify the styles used on your diagrams.

Structurizr's online editor

View and manage the set of decision records contained in the workspace.

Structurizr's online editor

Edit individual decision records.

Documentation as Markdown or AsciiDoc

Because the code doesn't tell the whole story, Structurizr also provides support for lightweight supplementary technical documentation, based upon a number of popular templates such as arc42.

The documentation is a collection of Markdown or AsciiDoc documents, one per section, which are rendered in the web browser. You can either upload existing Markdown/AsciiDoc files using the client libraries (thereby keeping your documentation in source code control), or edit documentation via the browser-based workspace-editor.

Diagrams from the same workspace can be embedded straight into the documentation, and the full-text search makes it easy to find what you're looking for.

Structurizr documentation screenshot

Structurizr architecture decision records screenshot

Architecture decision records

Because diagrams alone can't express the decisions that led to a solution, Structurizr allows you to supplement your software architecture model with a decision log, captured as a collection of lightweight Architecture Decision Records (ADRs) as described by Michael Nygard, and featured on the ThoughtWorks Technology Radar. Structurizr allows you to publish your ADRs to allow team members get an "at a glance" view of the current set of ADRs, along with facilities to make navigating them easier.

As with the documentation support, you can either upload existing decision records (e.g. those created using adr-tools) via the client libraries, or manage them via the browser-based workspace editor.

Explore your software architecture model

Once you have a model of your software system, extracted from your code using reflection and static analysis techniques, you can additionally visualise the model in a number of different ways. Structurizr provides some explorations to help you explore the elements and their relationships in the model.

Static Structure - Tree

Explore the software systems, containers and components defined in the model.

Static Structure - Size - Circles

View model elements ranked by size.

Dependencies - Components

Explore the afferent, efferent and cyclic dependencies between components.

Dependencies - Components and Code

Explore the dependencies between components and code.

Far too many teams allow their codebases to grow without having an insight into the structure of the code. The result is often the proverbial "big ball of mud"; a codebase that is tangled, hard to understand, hard to work with and hard to change. Visualising the structure of your code is the first step towards improving it.


Big Bank plc

Big Bank plc
(System Landscape, System Context, Container, Component, Dynamic and Deployment diagrams)

Financial Risk System

Financial Risk System
(System Context diagram, and documentation)

Spring PetClinic

Spring PetClinic
(System Context, Container, Component, Dynamic and Deployment diagrams)

Message bus and microservices

Message bus and microservices
(Container and Dynamic diagrams)

Widgets Limited

Widgets Limited
(System Landscape, System Context and Dynamic diagrams)

Contoso University

Contoso University
(System Context, Container, Component and Dynamic diagrams)


This video shows some of the basic features of the diagram editor.

This video shows some of the diagram navigation features.

This video shows some of the basic features of the browser-based workspace editor.