I do a lot of diagramming these days. Visual collaboration is extremely important in my daily (architect) job, especially for remote communication when direct, face-to-face interaction is a rarity and exception (instead of being a rule).

When it comes to visual modeling, I identify three categories of tools:

  • 100% manual sketching (preferably with a stylus) - no templates, no stencils, no icons, just a whiteboard space, and you - go wild!
  • diagramming with stencils & icons, but w/o semantic model behind - drag-and-drop objects, links between them, but there's no logic validation - e.g., a database may issue asynchronous requests to a user
  • model-based tools - strongly opinionated, based on particular notation/method (e.g., UML, C4, DDD) - makes you able to re-use (smartly) elements of the model in various perspectives, e.g., you can move up-down across different levels of detail/abstraction

In 90% of cases, I pick the tool from either the first or the third category.


The first one is brilliant for rapid, ad-hoc sketching (w/o many assumptions/up-front knowledge) and if you know that the result doesn't have to be long-living. My tools of choice here are Bluescape and reMarkable 2 (with LiveShare).

The third approach is much better for the well-structured, collaborative workshops when the goal isn't simply to illustrate a concept but to work some lasting solution out. However, I still struggle to find a tool that would meet the majority of my needs (Enterprise Architect? Never again!). To be more specific - the tools I know are good either in presenting the "logical architecture" (domain composition, component split, etc.) or "infrastructure architecture" (cloud services and deployment concepts) but never both.

Mixing the perspectives

Both perspectives are essential but insufficient in separation:

  1. "logical view" helps in building a loosely coupled, business-value-focused solution that separate, independent teams can develop independently
  2. "infrastructure view" enriches the logical perspective by adding crucial implementation details and covering key non-functional architectural concerns (like scalability, resilience, and such)

So the idea is to mix them in a thoughtful, frictionless way. Easier said than done.

A few months ago, I learned about the tool that could potentially fill that gap - it's a web SaaS named IcePanel. I solemnly promised myself to check it out thoroughly, but unfortunately, I didn't have enough time to give it a proper go until recently. Today I (finally) feel ready to share the initial bunch of my impressions with you folks.

Buckle up, here we go.


A tiny disclaimer: I initially planned peppering this review with numerous screenshots. However, this tool truly shines because of its interactive nature and fluid transitions between different perspectives. That's why - if you'd like to see it in action - I suggest following this demo link and checking how the tool looks like in action (w/o any registration or necessity to input any data).

"Ice Ice Baby"

First of all, it's not a UML-based tool. Some may find it a drawback, but I'm not in this group, because of the entry threshold UML puts in front of all involved parties. IcePanel relies heavily on the so-called C4 model, created and preached by Simon Brown. C4 stands for Context-Containers-Components-Code, and you can read more about it here. The most important things about this model are:

  • it's hierarchical, so it supports fluid traversal between various levels of detail
  • it corresponds to typical (high and mid-level) building blocks of software architecture (composition constructs), so it's easy to identify, mark and track 1:1 correspondences between C4 model components and actual source code artifacts (regardless of low-level paradigm: like OO or Functional design)
  • it's flexible - there are no strict bounds to any particular language/platform/framework
  • its notation is VERY simple - there are very few symbols to learn and memorize

In fact, many C4 tools (like Structurizr) support creating model diagrams straight from code (& accompanying meta-data) - it's a good solution for someone who'd like to make sure that diagrams remain 100% up-to-date (even if it means reduced readability).

IcePanel is slightly different. It's a model-first kind of tool (you need to sketch the model yourself), but you can "attach" links to code repositories to validate the correctness of your model ("trust score"). Frankly, I didn't try that - my use case is different: I typically co-operate with startup-ups to shape the future model of their platform (when there's barely any code yet or when the "as-is" model differs significantly from the "to-be" vision).

Secret sauce

Anyway, let's get back to IcePanel.

Its visual editor allows you to drop C4 constructs on the top 3 levels of the C4 model and "drill down" between them freely. Additionally:

  • you can create "areas" - conceptually groups items into packs that "belong together" (e.g., are deployed together - but more on that together)
  • you can "tag" them - tags can be related either to technology, release version, or whatever else you pick
  • at the app level (only), you can annotate them with icons - IcePanel provides a nice library of icons to choose from, incl. all the popular cloud services
  • each item has its own placeholder for description (in Markdown) - templates are supported (if you're struggling)
  • you can connect elements via connections; connections are named, can be tagged, and have a separate description as well

You can swiftly navigate across the whole model - each element has a dedicated diagram, but you can drag whatever you want (from the list of already added items) into it - if it's on a correct conceptual level. The word "drag" is essential here - this doesn't work like Paint or Photoshop - you don't need to "draw" it (and set all the properties) again, just pick the object from the already created and maintained (in IcePanel) model. That is VERY convenient as it:

  1. helps you to avoid typos and duplication
  2. assists in detecting unreferenced ("orphan") items

A bit of dynamics

There's also one very interesting feature that is NOT the part of the original C4 model (AFAIK) - diagram flows. It's a conceptual equivalent of UML sequence diagrams - you describe a single use case (or business scenario) by visualizing the sequence of interactions between particular C4 model components in a chronological way. To be frank - it's very intuitive and ... saves time. You don't need to create another (new) diagram but mark it as a transparent layer on the top of the existing model.

One potential drawback is that the connections between items become less "technical" ("JDBC connection", "access to all User data") and more "logical" ("register new meeting", "sync invoice data with cash balance"). That is not necessarily a bad thing, but it may seriously inflate the number of connections (which could potentially impact the comprehensiveness of diagrams).

Reality check

OK, great, but how does it all work in practice? Quite well, IMHO.

  1. The tool is visually appealing, responsive, and pretty intuitive.
  2. Yes, there are some minor bugs. The most annoying one happens quite frequently - clicking a diagram element doesn't open its details in the right panel (so you pretty much can't interact with that element) - refresh is enough to fix the situation.
  3. Layouts appear "smarter" than in other tools - e.g., adding/moving elements to the area automatically expands it, so everything is visually contained. It seems like a tiny detail, but in fact, it's a nice QoL feature.
  4. The C4 model requires some time to get used to, but you'll fall in love with its simplicity in time. I have yet to find an architectural construct/concept I won't be able to reflect in C4.
  5. Tags act as selectors - e.g., you can pick all the items on AWS or what's going to be released in version XYZ.
  6. The icons on the container level (don't mistake it with Docker containers ...) add a lot of clarity to the diagrams.

Few noteworthy (but not necessarily super-intuitive) observations:

  1. Connections do not "beam up". What do I mean by that? If you put a connection between a component and a DB and then zoom out to the app (container) level, there won't be a connection visible between the app (that contains that component) and the DB (unless you decide to add it manually).
  2. Connections are not draggable (you can't drag an existing connection into another diagram).
  3. Let's imagine you have a connection between two items: X and Y. If you drag both X and Y into another diagram, the connection between them won't appear "auto-magically".

The tool has a few features I haven't used yet: linking to code (I've already mentioned that) & "trust score", versioning via freezing, and team collaboration.

Conclusion(s)

I'd like to be super-clear here - this is NOT a tool for someone with purely infrastructural concerns in mind, e.g.:

  • How should we set up networking for this solution (how many VPC as subnets, how to deal with peerings and VPN connections, etc.)?
  • How to design multi-AZ redundancy (or load balancing strategy) for that bunch of services on the Kubernetes cluster?
  • How to organize AWS account structure and/or principals (user/group/role) access rights?

The tip of the scale here is definitely on the "logical" modeling side, but the rich annotation model (tags, icons, grouping with areas) is flexible enough to cover infrastructural aspects sufficiently (IMHO) for 80+% of use cases.

However, for a complex model with a proper (decoupled, domain-oriented) element composition, it's possible to have a "parallel", purely infrastructural view of the same elements (e.g., "here's my Kubernetes cluster, with all the pods running various logical services"). You can add manually new diagrams, but they all start on the (top) "Context" level. Also, keep in mind that L+1 element can be nested only in a single L element (e.g. one single app can't be a part of two systems).

If you find that approach counter-intuitive or hard to cope with, you'll need to sketch your "infrastructure" views independently (in a tool like Cloudcraft).


Unfortunately, IcePanel pricing has some serious drawbacks:

  • yes, there's a free model, but it's heavily limited (2 projects, 5 flows, 2 tag groups, etc.) - that's far from sufficient even for a solo cloud consultant modus operandi
  • the lowest paid tier is 20 bucks per month (paid yearly ...) AND it requires at least 5 paid team members; yikes ...

Nevertheless, TBH it's the best C4-based tool I've ever used. It's user-friendly, sleek, effective. Actually, it can be used as a nice practical "demo" to convince someone that C4 (regardless of its simplicity) can become a new standard for visualizing software architecture.

It's not perfect, but it gets regular and substantial updates (roughly every 2 weeks), it has a public roadmap, and its potential is evident at first glance. Personally, I'll be definitely checking it out regularly (how it develops, what are the additions), keeping my fingers crossed for:

  • regular updates of demo panel ;) - currently, it doesn't contain any flows
  • a change of pricing approach - a reasonably-priced (and limited ...) consultant plan would be a nice addition (IMHO)

P.S.

I am in no way affiliated with the developers or owners of the applications reviewed or mentioned in this article. My views and opinions on these applications are strictly private and should not be attributed to any of my employers, neither current nor past. I did not benefit from creating this review (neither materially nor in any other way).