The Polymorphic Diagram: Binding Declared Business Flows to Runtime Telemetry in Governed Architecture-as-Code

Enterprise architecture diagrams and production observability describe the same system from opposite directions, and in most organizations the two never meet. Diagrams are declared top-down, encode business intent, and go stale the day they are drawn. Service maps are inferred bottom-up from traffic, are always current, and carry no intent: they cannot say which paths matter, what a path is for, or what its owner promised about it. This paper describes a pattern — flow-bound architecture — that closes the gap by making business flows first-class, governed artifacts inside an architecture-as-code system. A flow is a declared, versioned path through a typed component graph, carrying business ownership, criticality, and service-level objectives. Flow identity is propagated into runtime telemetry as trace context, so every span, metric point, and cost record is attributable to a declared flow. Three properties follow. First, coverage becomes checkable: a declared flow step with no corresponding telemetry is a named observability gap, not an unknown unknown. Second, drift becomes checkable in both directions: observed paths that match no declared flow, and declared flows with no observed traffic, are conformance findings in the sense of software reflexion models. Third, the architecture canvas itself becomes an operational surface: because nodes and edges on the diagram are the same identities that appear in telemetry, live SLO status, cost, and nondeterminism levels render directly onto the declared diagram, turning the design artifact into an SRE console. We name the resulting artifact a polymorphic diagram: one governed base presenting as many diagrams, along orthogonal — independent, composable — facets (network, identity, flow, cost) over an invariant identity-and-layout base. The pattern extends the author's previously published flow-based telemetry coverage method (Zenodo, DOI 10.5281/zenodo.21415948) from an observability-governance discipline into a closed architecture-governance loop. We situate the pattern between architecture description languages, service-mesh topology inference, SLO practice, and process mining; define the flow descriptor and its telemetry binding; describe the governance model (Git-authoritative artifacts, runtime stores as rebuildable projections, infrastructure materialized through policy-scanned composition); and discuss limitations including attribute cardinality, sampling floors, asynchronous fan-out, and partial adoption. An open specification with JSON Schema definitions and a reference validator accompanies the paper.