Sketch to Diagram

Sketch an architecture by hand and let Circuitry turn it into a real diagram — shapes with labels become blocks that move as one, arrows become connections that follow, and the whole sketch converts into live workflow nodes, each typed from what you called it.

When you're planning, the fastest way to think is to draw. On any Workflow canvas, switch to drawing mode and sketch the way you would on a whiteboard. Circuitry quietly recognises the structure behind your sketch so it behaves like a diagram instead of loose ink.

Virtual nodes — a shape with a label

Draw a shape (rectangle, ellipse, circle, diamond, triangle) and put a text label inside it — handwrite it with the Write pen (it converts to text as you write) or type it with the Text tool. You can also add the label first and draw the shape around it. Circuitry recognises that the two belong together and groups them into a single block:

• The shape and its label move together as one object — drag either and both follow.
• The label is gently centered inside the shape.
• It's the same gesture you'd use to sketch a button for a UI mock-up.

Recognition is deliberately conservative: it only groups a shape with text that is clearly inside it. Freehand ink inside a shape — a doodle, a face, decoration — never triggers grouping, and unrelated notes that happen to overlap a big frame are left alone. If it ever groups something you didn't mean, just Ungroup (right-click, or ⌘⇧G) — nothing is permanent.

You can turn this off any time in Settings → Drawing → Sketch to Diagram → "Auto-group sketches into nodes" (it's on by default). With it off, you can still group manually with ⌘G.

Group blocks into groups

Blocks nest. Select a few button blocks and group them into a menu bar; group several menu bars into a header. Grouping is hierarchical, so ungrouping peels one level at a time — ungroup the header and the menu bars stay intact; ungroup a menu bar and the buttons stay intact. Your deliberate sub-groups never explode back into loose strokes.

Labels on their own

A block doesn't need a shape around it. Write or type a label on its own — "Fetch API", "Send email" — and it becomes an object you can drag, connect and convert. Handwriting is grouped into one label per phrase as you write, and is read into text when you convert, so you never have to type what you've already written.

Virtual connections — arrows that follow

Draw an arrow from one block toward another. The arrow doesn't need to touch perfectly — if it clearly points from one block to another, Circuitry tags it as a connection. From then on, whenever you move a block, its connections re-anchor to keep touching both ends. Rearrange your sketch freely; the arrows keep up.

You don't need the arrow tool. Draw a plain straight line between two labels and it becomes a connection on its own — the line tidies itself straight and starts following both ends. No arrowhead is added, because you didn't draw one. A line only converts when it clearly runs between two different labels, so illustration strokes, hyphens and stray marks are never swept up.

Select a connection to get a round handle at each end. Drag a handle to re-connect it somewhere else; it snaps to whatever label you drop it near, and keeps a comfortable gap from the writing rather than touching it.

Convert a sketched architecture into nodes

When the sketch captures what you want, make it real. Select your blocks, labels and connections, then press To Node in the selection toolbar. Circuitry:

• Reads each handwritten label into text.
• Creates a real node for each block, keeping its label and position.
• Turns each connection into a real edge between the nodes.
• Infers the node type from the label — a block called "Send email" becomes a Msg node, one called "user database" becomes a DB node.

The whole conversion is a single step you can undo (⌘Z) to bring your sketch back exactly as it was.

When types are inferred, and when they aren't

Circuitry looks at the whole selection before typing anything. If your labels read like a system — several of them match known node types — you get typed nodes. If it reads like a plain diagram of boxes ("Process", "Step two", "Handle it"), every block becomes a neutral Flow node instead, because you're laying out a plan rather than building a workflow. A single incidental keyword in an otherwise generic diagram won't flip it.

Generic diagramming words — process, task, step, node, handle — are deliberately ignored, so they always stay Flow.

Draw the symbol, get the node

Two nodes are drawn as symbols rather than words — that's how they appear on the canvas once converted, and that's how you can sketch them.

Write a lone brace and you get the node whose icon you just drew. It has to be the whole label: a brace inside a longer label is left alone, so "for each {item}" is still a Loop because of the words, and a template like {{input}} is never mistaken for one.

Name the mode, get the mode

Some nodes do many things. Vision and ImgOps each have a long list of operations, so naming the operation tells Circuitry more than naming the node. Write "remove background" and you don't just get a Vision node — you get a Vision node already set to Remove Background. Write "favicon" and you get an ImgOps node set to build a favicon set.

Naming an operation always beats naming the node, so "crop image" is a Crop, not a plain Image.

Vision — reading, reasoning about, and modifying pictures:

ImgOps — deterministic image work, no AI:

An inferred mode arrives fully configured — a Resize lands with sensible dimensions rather than an empty panel — and you can change it in the node's settings like any other.

Shorthand

You don't have to write labels out in full. Common abbreviations are expanded before anything is matched, so "rm bg from img" reads as "remove background from image" and lands on the right node and mode.

Nodes that stand alone

A couple of nodes have no connection points at all. Terminal is a real shell you work in, and a Sticky Note is a comment — neither takes part in the flow of a workflow, so neither has anywhere for an arrow to land.

Circuitry won't hand you one of those with an arrow attached to it. If you drew a connection to the box, it converts to the connectable equivalent instead:

So a sticky note off to the side of your sketch stays a sticky note, while the same words wired into the flow become a Text node carrying that content onward. Draw whichever reads more naturally; the connection decides.

What each label becomes

Matching ignores capitalisation, and any label that matches nothing becomes a Flow node. Where a label contains two keywords, the one higher in this table wins — so "database table" is a DB node, while a bare "table" is a Sheet.

These are the node types. An operation named from the tables above always wins over anything here.

Two words are left out on purpose. "then" is the commonest word in a hand-written label ("then save the file"), so it never outranks the node you actually drew. And a bare "file" loses to "upload a file", which is a node that asks the person running the workflow to pick one.

Changing a node's type after conversion

Nothing about the inference is final. Select any node that came out as a neutral Flow node and press Convert to in the selection toolbar — search for the type you want and pick it. The node keeps its label, its position, and every edge already attached to it.

Nodes that were given a real type work the same way, from the right-click menu. So if "query the API" came out as a DB node when you meant an HTTP Request, right-click it and change it — you don't have to redraw anything.

Tip: if you'd rather type everything yourself, sketch with generic labels. A diagram of "Step one, Step two, Step three" converts to plain Flow nodes, and you convert each one by hand.

Related

• The Smart Whiteboard — the full think / plan / direct / communicate picture
• Vector Graphics & Drawing
• Workflows Overview
• iPad Gestures & Touch Controls