System Modelling Toolbox: Is There a Master Key to Rule the Design Phase?

My analytics lead has recently decided to document all existing integrations. The intention is benevolent unless the tooling is mandated. Confluence, of course — one tool to ruin it all with no support for markup and search accuracy close to a coin flip. I decided not to abandon the idea, but rather to add it some more sense.

I tested head to head common notations that cater to arcitecture design. What I’m looking for is:

• formality that guardrails the design from any deviations — this is something that clearly divides a notations from tools like draw.io or Lucidchart.
• level of adoption — community support and support by modelling, authoring and software development tools.

I came to search for a tool to design a basic architecture layout quite recently, being a loyal adopter of PlantUML. But UML suggests designated types of diagrams to support layered architecture design. However, when drafting a solution on a flipchart, you are least likely to observe any notation, and for this reason I included ease of use and versatility into my assesment criteria.

D2

I came across D2 in 2025, and at first glance over examples, I became convinced that this is my go-to diagramming tool. For the time being, D2’s popularity is no match for UML. That’s why ChatGPT will convert a deployment diagram exported from Figma into a complete jibberish. Here, it should be mentioned that D2 supports three engines: two free and one commercial.

It took me couple hours to build a diagram that resembled the original in Figma. Documentation is easy to navigate and follow alongside with the examples in D2 Playground. Example listings come handy too. Here’s my take on ‘Hello World’ (a Loan Conveyor).

direction: right
​
classes: {
  base: {
    style: {
      bold: true
      font-size: 28
    }
  }
​
  person: {
    shape: person
  }
​
  animated: {
    style: {
      animated: true
    }
  }
​
  multiple: {
    style: {
      multiple: true
    }
  }
​
  library: {
    style: {
      bold: true
      font-size: 32
      fill: PapayaWhip
      fill-pattern: grain
      border-radius: 8
      font: mono
    }
  }
​
  task: {
    style: {
      bold: true
      font-size: 32
    }
  }
}
​
lc: {
  label: "Loan Conveyor (LC)"
  bl: {
    label: "business logic"
    icon: https://icons.terrastruct.com/dev%2Fjava.svg
    width: 160
    height: 160
  }
  scoring: {
    icon: https://www.r-project.org/logo/Rlogo.svg
    width: 160
    height: 160
  }
  abd: {
    label: "application \n database\n"
    icon: https://icons.terrastruct.com/dev%2Fpostgresql.svg
    shape: cylinder
    width: 160
    height: 230
    style: {
      fill-pattern: lines
      font: mono
    }
  }
  bl -> abd
  scoring <-> bl
  mc <-> bl
  bi: {
    label: "KPIs and process \n analytics \n"
    icon: "https://upload.wikimedia.org/wikipedia/commons/thumb/b/bf/Shiny_hex_logo.svg/960px-Shiny_hex_logo.svg.png"
  }
  abd -> bi
​
  mc: {
    label: "LC dashbord and configuration"
    icon: "https://icons.terrastruct.com/tech%2Fbrowser-2.svg"
    width: 160
    height: 230
  }
}
​
sc: {
  label: "Social \nServices\n"
  width: 160
  height: 230
}
​
cra: {
  label: "Credit \nReporting\n Agency"
  width: 160
  height: 230
}
lc.bl <- cra
lc.bl <- sc
mobile: {
  label: "mobile app"
  icon: "https://icons.terrastruct.com/aws%2F_General%2FMobile-client_light-bg.svg"
  width: 160
  height: 230
}
​
web: {
  label: "web app"
  icon: "https://icons.terrastruct.com/tech%2Fbrowser-2.svg"
  width: 160
  height: 230
}
​
user01: {
  label: Client
  class: [base; person; multiple]
}
​
user02: {
  label: Manager
  class: [base; person; multiple]
}
​
user03: {
  label: DA \n C-level
  class: [base; person]
}
​
user01 -> mobile: {
  label: "Place a loan request / view progress"
  class: [base; animated]
}
​
user01 -> web: {
  label: "Place a loan request / view progress"
  class: [base; animated]
}
​
user02 -> lc.mc: {
  label: "Process requests / edit settings"
  class: [base; animated]
}в
​
user03 -> lc.bi: {
  label: "View stats"
  class: [base; animated]
}
вфеф
mobile -> lc.bl
web -> lc.bl
​

D2: Loan Conveyor deployed

Not very compact, right? Very incompact, to be exact. But as you write, the code follows your way of thoughts: let’s add a database, let it be postgre, ehm… let’s give it some lavender flavor and add a striped fill pattern. I don’t need to memorize different types of primitives and syntax. Indeed, a person shape is as easy as shape: person.

Nested containers are as easy as nesting objects in a JSON.

However, I noticed that two-line labels are overlapped by icons, and you need to adjust styling by adding line breaks or height. As you can see in the diagram, Managers have larger head circumference, as compared to regular clients — a fact against which D2 is powerless.

I am subscribed to ByteByteGo, and I have seen numerous times people asking about the tools they use to create animated diagrams. D2 adds this aesthetic twist with an animated class.

From our brief acquaintenance, D2 feels like a pencil, connecting directly the medium and the brain. I couldn’t manage to run a script in R Studio using a designated library, but I suppose I need to make another approach.

Mermaid

Mermaid is running for a pole position with a couple dozen tools under the belt. Architecture diagrams is one of many. Here’s what my Credit Conveyor looks like in markdown:

---
config:
    theme: dark
---
architecture-beta
group lc[Loan Conveyor LC]
service db(logos:postgresql)[application database] in lc
service bl(logos:java)[bisiness layer] in lc
service viz(logos:google-analytics)[KPIs and performance metrics] in lc
service sc(logos:logos:r-lang)[scoring] in lc
service web(internet)[LC dashboard and configuration] in lc
service wa(internet)[web app]
service ma[mobile app]
service ca(database)[Credit Reporting Agency]
service ss(database)[Social Services]
​
web:L <--> R:bl
db:L <--> R:bl
bl:L --> R:viz
sc:T <--> B:bl
wa:B <--> T:bl
ma:R <--> T:bl
ca:R <--> L:bl
bl:L <--> R:ss

Mermaid syntax allows for explicit alignment of elements. Icons are limited to logos from Iconify, unlike with D2 where you may link any image on the web. These icons are, however, not rendered by the mermaid library in R. The code above looks much more concise, but ‘beta’ status in the first line hints at the quality.

Not all mermaids drag you down into the sea, some make your eyes bleed.

Work in progress? The pallette of components does not include actors. The primitives are limited to only squares. And I couldn’t make use of ‘edges’ — the semicolon-separated letters to define alignment. After all, I could have connected logos without any notation. My enthusiasm slows down.

SysML

The name itself is dignifies the paradigm of MBSE. Indeed, what other markup language could be a briter star in the system engineering universe?

SysML has survivd a pivot turn from a visual-first to a code-first (in ver.2) design approach. I had to spend few hours installing and getting around various tools and plugins. Commercial ones cost as much as a wing of a Boeing and are claimed to be used by companies like Boeing.

Astah SysML, listed as top shareware package, has a UI designed in the Bronze Age. It does support internal block diagram which is akin to UML’s deployment diagram. But the desktop solution throws an error dialog telling me that I need to first select something in the structure pane, which I failed finding. I wonder if system designers at Astah have ever met humans or if they still survived on the reverse side of the Earth inhabited by dinosauri. And of course, not even a quick start guide is available to run their plugin under the VS Code.

The other of the two extensions available at VS Marketplace is ‘SysML v2 Support’. Thanks to the code assistant, I created the following piece by typing the package name and a tab stroke to accept the suggestion.

package 'Credit Conveyor' {
    block 'Credit Application' {
        part 'Applicant' {
            attribute 'Name' : String
            attribute 'Age' : Integer
            attribute 'Income' : Float
        }
        part 'Credit History' {
            attribute 'Credit Score' : Integer
            attribute 'Number of Late Payments' : Integer
        }
        part 'Loan Details' {
            attribute 'Loan Amount' : Float
            attribute 'Loan Term' : Integer
        }
    }
}

Credit Conveyor, general view

That’s not the most you can get from SysML support. There are also:

• Interconnetion,
• State,
• Activity,
• Sequence,
• Case,
• Tree,
• Package,
• Graph,
• Hierarchy.

If you are familiar with UML, you may see some resemblance in the types of diagrams. And indeed, SysML is a rocket stage of UML by Object Management Group. But my intention was different from the visual above. Unfortunately, I could not replicate my Loan Conveyor design, as with D2 or Mermaid, because SySML under VS Code does not support internal block diagrams or block definition diagrams.

I may invest more into discovery of other SysML tools. But until now I shall conclude quoting official SysML site:

• No SysML v2 tool currently matches SysML v1 graphical maturity.

• Simulation and execution support remains early-stage across vendors.

• Textual modeling capabilities are generally more mature than graphical features.

• Standards compliance is improving but still evolving across implementations.

SysML v2 tooling continues to develop, but the ecosystem remains in a transitional phase compared to mature SysML v1 platforms.

I wish SysML evolved into something other than just a spin-off of UML and managed to keep various types of designs attached to each other, e.g. an activity diagram may reuse components and maintain dependencies with a usecase diagram, likewise with IBD and sequence.

Conclusion

At this point I have to conclude that all technologies, eventhough addressing basic modelling scenarios, do not add much extra to diagramming tools (MS Visio) or do not include tools to run the design phase of SDLC from solid requirements to a blueprint. SysML includes a REQ (requirements) diagram, but lacks support of component diagrams in VS Code. Mermaid is playful when it comes to system interactions, yet waives being incapable of designing logical architecture.

My virtuous quest towards MBSE is not yet over. But I will stick to PlantUML in the meantime.