NEW CAPABILITY

See the whole system,
not just one program.

A Program Logic Manual tells you what one program does. The System Data & Control Flow map tells you how the entire estate hangs together: every program, every call and control transfer, every dataset, DB2 table and IMS database. Click any program to drill inside it, all the way down to the data flow between paragraphs.

83linked, navigable views
4cross-linked reports
51nodes in the system graph
0elements hand-drawn
The AWS CardDemo system, mapped
This is the real generated artifact, not a picture of one. Hover a program box for a plain-English summary of what it does, scroll to zoom, drag to pan, and click to drill in. Everything below was produced automatically from the same parsed fact base that generates our Program Logic Manuals.
brevidy.com/flow/system_flow.html

Best experienced full screen. The map is self-contained: no network calls, no installation.

What happens when you click an element
Every program box is a door. Each level is a real browser history entry, so Back, Forward, bookmarks and shared links all behave the way people expect. Follow the same program, CBTRN03C, down all three levels.
LEVEL 01

System call & transfer graph

Every program and the calls, links and control transfers between them. Legend checkboxes switch whole subsystems on and off so you can isolate one area at a time.

Open level 1 →

LEVEL 02

Job & file flow for one program

Click a program box and you get its world: the JCL steps that run it, the datasets and DB2 tables it reads and writes, and the programs on either side of it.

Open level 2 for CBTRN03C →

LEVEL 03

Paragraph-level data flow

Click the program again and you are inside it: how data moves between paragraphs, where each field is set, and which paths lead to which outcomes.

Open level 3 for CBTRN03C →

CBTRN03C is the daily transaction posting batch program. Follow it through all three levels above, then read its complete gold-standard Program Logic Manual. Same program, same parsed facts, two different ways of seeing it.
Every tooltip says where it came from

Hover any program box and a plain-English summary of what that program is for appears immediately, so someone new to the estate is not left decoding eight-character names. The detail that matters: each tooltip is labelled with its own provenance. Text taken from the source header comment is marked as such. Text drawn from the generated Program Logic Manual carries a and is noted as verified against source facts. Anything describing an external vendor routine carries a and says whether it is vendor-documented or curated from call context.

Even the hover text refuses to blur the line between what the code proves and what a human wrote about it.

The questions maintenance teams actually ask
The map answers more than "how does this connect." Each report below is cross-linked from the others, and each one exports to TSV for spreadsheet and audit workflows.

How does it all hang together?

System flow. The call and transfer graph, 51 nodes, with job & file flow and paragraph-level views for each of 40 programs.

Open the flow map →

Who touches what?

CRUD matrix. 34 programs against 38 data stores. Every Create, Read, Update or Delete marker opens the paragraph and source-line cites that prove that access.

Open the CRUD matrix →

What runs before what?

Batch dependency chain. Job ordering derived from shared datasets, with the writer/reader pair, deck, step, DD and disposition behind each link. It states its own JCL coverage rather than implying completeness.

Open the dependency chain →

What never runs?

Static findings. 29 findings across 12 programs: uninvoked paragraphs, unreachable code after transfers, silent I/O failures, unrounded computes, accumulator double writes. Each expands to every recorded field and source cite.

Open static findings →

What breaks if I change this?

Impact analysis. Select any program or data store and trace its cited upstream and downstream blast radius, 1,490 closure rows across 118 assets. Depth is user-adjustable and visible, the trace follows static call and data-access facts rather than runtime scheduling, and unresolved dynamic targets are excluded rather than guessed at. This is the report a change-advisory board asks for and almost never gets.

Open impact analysis →

Nothing here is drawn by hand or guessed
A diagram that looks confident but cannot be checked is worse than no diagram, because people act on it. Every element in these maps is derived from deterministically parsed source: COBOL programs, JCL decks and CICS definitions.

Every arrow traces to source

Each call, transfer and data access maps back to specific source lines. There is no interpretive layer between what the code says and what the picture shows.

Unproven targets are shown as unproven

Where a dynamic transfer target cannot be established from the source, it is displayed explicitly as unresolved rather than guessed at. An honest gap is more useful to an engineer than a confident invention.

Same fact base as the manuals

The maps and the Program Logic Manuals are generated from one parsed baseline, so the diagram and the documentation cannot drift apart or contradict each other.

Built for audit, not just for reading

Views are bookmarkable and shareable as links, and the CRUD matrix exports to TSV for spreadsheet and audit workflows.

Open them yourself
Generated from the AWS CardDemo benchmark corpus. Nothing is behind a form.

Every report also exports to TSV for spreadsheet and audit workflows: CRUD · impact closure · static findings · batch dependencies