Diagram gallery

A whole deployment in one frame: named phases across the top, a boundary around what one host runs, and the concerns spanning it. Use when the reader needs the shape before the parts.

Fall back: Without named phases across the top and a concern spanning every box, the stack inside its boundary is a deployment.

Nodes placed inside network or environment boundaries, each carrying the version it runs. Use when placement is the question: which zone, which host, which version.

Fall back: Without a boundary or a version to place, the nodes are an architecture.

What depends on what across packages, and where those dependencies concentrate. Use when one package carries several dependents, or when an edge points backward into a cycle.

Fall back: Without a shared dependency or a back-edge, the packages are a tree.

Hierarchy expressed by containment. Use when the relationship is "lives inside", not "reports to".

Fall back: Without genuine containment, the hierarchy is a tree.

Stacked abstractions where each layer depends on the one below. Use when the vertical ordering carries the meaning.

Fall back: Without each layer depending on the one below, the rows are a tile-list.

Parent-to-children branching. Use when every node has exactly one parent and the depth is the story.

Fall back: Without depth past one level of children, the nodes are a tile-grid.

Ownership and routing across people or systems. Use when accountability, not data flow, is what the reader needs to trace.

Fall back: Without a named owner on each box, the reporting lines are a tree.

Zoned inventory of where each system lives, with the hand-offs across the boundary named. Use when the reader needs the legacy estate and its replacement side by side.

Fall back: Without zones grouping the boxes by where they live, the systems are an architecture.

Which sources plug into a platform and which surfaces consume it, every wire naming what it speaks. Use when the number of integration points is itself the claim.

Fall back: Without a protocol on every wire crossing the boundary, the platform and its neighbours are an architecture.

Who talks to whom, in what order. Canonical estate example: tutti's UPnP SSDP → descriptor → SetAVTransportURI exchange.

Fall back: Without a second actor exchanging messages, the run is a state-flow.

States and the transitions between them. Use when the set of possible system conditions is finite and the triggers matter.

Fall back: Without a transition that loops back, the states are a state-flow.

End-to-end CLI pipeline sequence. Distinct from sequence (which is RPC-style); state-flow is pipeline-of-stages. Canonical example: patinate's auth → fetch → sync → render.

Fall back: Without each stage feeding the next, the commands are a tile-list.

A flow that crosses functional boundaries. Use when ownership and handoff points are as important as the steps.

Fall back: Without a handoff crossing a lane, the flow is a flowchart.

Sequential steps across actor lanes, each carrying its payload and tool. Use when who does the step, what enters and leaves it, and which tool runs it all have to be legible at once.

Fall back: Without the payload and tool on every step, the lanes are a swimlane.

Typed payloads moving through ordered pipeline stages, each stage scoped to a role. Use when the reader needs to see what shape the data takes at every handoff, not just who owns which step.

Fall back: Without a typed payload changing shape as it crosses lanes, the handoffs are a swimlane.

What a person does across the stages of an experience and how each stage feels. Use when the sentiment curve is the finding, not the sequence of steps.

Fall back: Without a feeling you can name at every stage, the stages are a timeline.

A cycle whose every pass writes back into one shared center. Use when the reinforcement is the point: work advances around the ring, and the hub it feeds makes the next lap cheaper.

Fall back: Without dashed write-backs into a shared hub, the ring is a state-machine.

Where a quantity goes as it splits across stages, with band thickness carrying the volume. Use when the reader needs to compare magnitudes, not just trace a path.

Fall back: Without a split or merge in the quantity, the stages are a pyramid.

One dataset held at rising quality and access levels, with the transform that promotes it between tiers. Use when what each tier contains and who may read it is the question.

Fall back: Without each tier changing the data's quality or who may read it, the stages are a state-flow.

Entities, their fields, and the relationships between them. Use when schema is the question the reader is asking.

Fall back: Without fields and cardinality on the relationship, the entities are an architecture.

Physical tables with SQL types, constraint chips, and foreign keys that anchor to a specific column. Use when the migration or the ON DELETE behavior is what the reader is reviewing.

Fall back: Without a foreign key that lands on a named column, the tables are an ER model.

Classes with their fields, their operations, and typed relationship arrowheads. Use when ownership, inheritance, or the behavior a type carries is the substance.

Fall back: Without operations or an arrowhead vocabulary carrying meaning, the boxes and their fields are an ER.

Who may do what, cell by cell. Use when the reader is auditing permissions across every actor and every protected surface at once, and one intersection carries the posture.

Fall back: Without a second actor to compare against, one surface's permissions are a tile-list.

A census of work in progress by state: what is queued, moving, stuck and done, with a WIP limit stated on every in-process column. A board shows state, not flow, so it carries no connectors.

Fall back: Without a stated WIP limit and a state on each card, the columns of cards are a tile-grid.

Narrative order left to right, release slices top to bottom. Use when the question is where the first release cuts, not what the backlog holds.

Fall back: Without a release cut slicing the columns, the cards are a kanban.

Tasks with a start, an end, and overlap on a shared time axis. Use when how long each stretch runs, and what runs alongside it, is the substance of the explanation.

Fall back: Without duration and overlap carrying meaning, the dated steps are a timeline.

Events placed on a shared axis. Use when sequence and relative timing are both load-bearing.

Fall back: Without relative timing carrying meaning, the events are a tile-list.

A scenario matrix with four named cells. Use when two binary dimensions define a decision space and you want each cell to carry a name.

Fall back: Without a name in each cell, the placement is a quadrant.

A value chain plotted against how evolved each component is. Use when the point is what is worth building and what should be bought, not how the pieces connect at runtime.

Fall back: Without the evolution axis carrying meaning, the value chain is a layer-stack.

Set overlap. Use only when the intersection is the point; a two-column table often says the same thing without the geometry.

Fall back: Without an intersection carrying meaning, the sets are a tile-grid.

Ranked hierarchy or drop-off across stages. Use when volume, priority, or survival rate changes as you move through levels.

Fall back: Without volume or drop-off changing across levels, the bands are a layer-stack.

One observed effect, its candidate causes grouped by category, and the one confirmed root cause. Use when the reader needs to see what was investigated, not only the conclusion.

Fall back: Without competing categories to rule out, one cause and its effect are a state-flow.

One numeric value per category, compared side by side on a zero-based axis. Use when the gap between categories, or against a threshold line, is the message.

Fall back: Without a numeric scale making the bar lengths comparable, the categories are a tile-list.

A measured quantity across three or more ordered points. Use when direction and rate of change are the argument, not the value at any single point.

Fall back: Without a measured quantity moving across the points, the marks are a timeline.

Items placed on two measured axes, where clusters and outliers are the message. Use when the reader should take away the shape of the whole set, not read off one item's rank.

Fall back: Without measured axes carrying a scale, the placement is a quadrant.

One subject scored across four or more criteria on a single shared scale. Use when the shape of the profile, where it maxes out and where it dents, is what the reader takes away.

Fall back: Without every axis sharing one normalized scale, the scores are a tile-list.

One measure across a repeating cycle, each category a ray whose length is the value. Use when the wrap from the last bucket back to the first is part of what the reader has to see.

Fall back: Without the categories wrapping into a cycle, the values rank as a bar chart.

Parts of one total, sized by area. Use when a single figure decomposes into sections and the reader's question is what dominates and by how much, not what each exact value is.

Fall back: Without relative size carrying the story, the parts rank as a bar.

N parallel facets of one thing, each carrying equal weight. Canonical example: every estate hero's FLOW/DISCIPLINE cluster.

Fall back: Without equal weight across the facets, the tiles are a tile-list.

N entries in an ordered sequence, where position matters. Canonical example: tutti's "where it goes wrong" failure modes.

Fall back: Without position carrying meaning, the entries are a tile-grid.