Flocci TechnologiesInfinity
System Architecture Diagrams

Architecture diagrams you can actually keep current

To diagram a system architecture, draw one shape per service, group them into frames by boundary, then connect dependencies with labelled connectors — solid for synchronous calls, dashed for asynchronous. Flocci Infinity's connectors re-route automatically, so the diagram survives the next refactor.

Architecture diagrams rot because editing them is expensive. Move one service box in a typical tool and you spend ten minutes repairing arrows, so nobody updates the diagram and it quietly becomes fiction. Infinity's connectors bond to shapes and recompute their own routes, which changes the economics: a refactor is a few drags, and the diagram stays close enough to true that people keep trusting it.

The notation is yours to define, and the primitives support a clear one. Frames mark boundaries — a VPC, a cluster, a trust zone, a team's ownership. Solid connectors for synchronous calls, dashed for asynchronous messages, dotted for optional or planned edges, using the four available dash patterns. Midpoint labels carry the protocol or the queue name. Seven arrowhead styles let you distinguish a request from an event stream without a legend nobody reads.

An infinite canvas also lets one board hold several zoom levels of the same system, which is usually what people actually want. A context-level view of the whole platform sits in one region; the detail of the payment path sits in another with its own frame and title; a third region holds the migration target state. Pan between them, use the minimap to navigate, and stop maintaining three drifting diagrams in three files.

Because you can embed live webpages as canvas cards, the runbook page, the dashboard or the repository README can sit beside the component it describes. Present mode then turns the board into a clean surface for an architecture review or an onboarding walkthrough — a new engineer follows the map with someone talking over it, which lands far better than a static PNG in a wiki.

How to do it, step by step

  1. 1Box the servicesOne shape per service or component, named, with frames marking boundaries like clusters, VPCs or team ownership.
  2. 2Draw the dependenciesConnectors between components; they bond to both ends and re-route themselves when the layout changes.
  3. 3Encode the semanticsSolid for synchronous, dashed for asynchronous, dotted for planned; midpoint labels for protocol or queue name.
  4. 4Add the zoom levelsKeep the context view, the detail views and the target state as separate regions on the same infinite canvas.
  5. 5Attach the runbooksEmbed the dashboard, runbook or README as live cards beside the components they belong to, and review in present mode.

Frequently asked questions

Does Flocci Infinity support UML or C4 notation?

There is no formal UML or C4 symbol library. You build the notation from shapes, frames, dash patterns and labelled connectors — which suits C4-style boxes-and-lines diagrams well. For strict UML compliance with a validated symbol set, a dedicated diagramming tool remains the better fit.

Can I keep several diagrams for one system?

Keep them as regions on a single infinite canvas rather than separate files: a context view, detailed subsystem views and the migration target state, each in its own titled frame. The minimap makes navigation between them quick, and there is only one artifact to keep current.

How do I show synchronous versus asynchronous calls?

Use the four dash patterns and seven arrowhead styles: solid with a triangle head for synchronous calls, dashed with an open head for asynchronous messages, dotted for planned edges. Midpoint labels carry the protocol or queue name so the diagram needs no separate legend.

Open a free board and try it

Free personal boards, no card. One Flocci account across 30+ apps, priced in rupees.

Open a canvas free