Processing maps

A processing map (or pipeline composer) is a product surface for any system whose runtime is ordered. If the engine applies steps in sequence, the UI shows that sequence as one editable map — not as a scatter of settings pages.

Core claim

Sequence as the top-level organization — on the processing-map / pipeline composer surface, not on every screen in the product. Parallelism, branching, and reuse nest inside steps as typed composites. Users insert steps between neighbors, but only rule kinds that fit the socket type.

Real admin UIs still wrap the composer in navigation, hero copy, and unrelated settings. The claim is that the spine inside the map matches the spine the engine runs.

This is an HCI stance on product representation: the map must match execution, or the product is lying about what counts.

Why it exists

Fragmented sequentiality forces users to hold the real pipeline in working memory. Classic failure: two vendors each own a redirect, a proxy toggle joins them into one path, and the browser reports a loop — while no admin UI ever showed both rules on one spine.

Anatomy

  • Map — ordered stages; empty sockets between steps

  • Typed sockets — insert palette filtered by valid rule kinds for that phase

  • Nested composition — linear sub-pipelines, parallel groups with join policy, conditionals that rejoin

  • Replay — sample input walks the map so debugging is reading, not folklore

  • Export — serialization matches what the engine loads

Design rules

  1. One map for one runtime order — if it runs in the path, it appears on the path

  2. Sequence at the root; nest parallelism

  3. Insert between, with types

  4. Summaries before forms

  5. Replay beats folklore

  6. Export is sacred

What it is not

  • Not BPMN theater

  • Not a default freeform node graph (use graphs when the domain is a graph)

  • Not a replacement for code review — the composer is the honest face of config

Prototype

Prototype architecture

Interaction-heavy composers should split core IR, headless controller, renderers, and thin host wrappers — not auto-export full UI. See Prototype strategy and Fundamental contexts.