Visual Maps for Runbooks
A recent demo video showcased AI-assisted mind maps and interactive visuals that convert scattered documentation into navigable knowledge structures, promising faster retrieval during incidents and clearer dependency views. The idea is to turn runbooks, postmortems and architecture notes into interactive maps that answer 'who owns this' and 'what breaks if X fails' — which is much easier for rotating staff to use than long linear SOPs. Pilot maps for 311, incident intake, and core infrastructure dependencies can make cross-training and triage far less brittle. (youtube.com).
Most runbooks are written like airplane safety cards taped into a filing cabinet: the steps exist, but the person on call still has to guess which page matters at 2:13 a.m. Rootly describes a runbook as a step-by-step guide for handling incidents, but the format is usually still linear text spread across docs, tickets, and chat threads. (rootly.com) The demo behind this story shows a different shape: paste in a document, webpage, slide deck, image, or YouTube link, and the system turns it into an interactive visual you can click, expand, and trace back to the original source. MyLens says every element is explorable and every insight can be traced to source material instead of living as an uncheckable summary. (mylens.ai) That changes what a runbook is for. Instead of reading top to bottom, an on-call engineer can start from one broken service, open the branch for dependencies, and see which system, team, or note sits behind the next hop. (mylens.ai) Modern systems are exactly the kind of thing that punish linear documents. Dynatrace says short-lived cloud components, Kubernetes services, and multicloud links change fast enough that hand-maintained diagrams go stale, which is why teams keep rediscovering the same ownership and dependency questions during incidents. (dynatrace.com) The two questions that eat the first minutes of an outage are usually simple ones: who owns this service, and what else breaks if it fails. Dynatrace pitches live topology maps around those exact answers, including upstream and downstream dependencies, blast radius, and ownership. (dynatrace.com) Traditional runbooks solve a different problem. PagerDuty’s service ownership guidance says documentation should help other people understand and operate a service so one engineer does not become a single point of failure, but that still assumes the next responder can find the right document fast enough. (pagerduty.com) That is why the visual layer matters more for rotating staff than for the person who wrote the system. A new responder may not know whether “incident intake,” “311,” or “core infrastructure” is the right folder name, but they can usually follow a map from the alert they have in front of them to the owner, the dependency, and the last postmortem. (mylens.ai) There is also a training angle here. Atlassian says an incident management handbook can include runbooks, checklists, templates, and training exercises, and a map turns those separate artifacts into one navigable surface instead of a pile of links. (atlassian.com) The practical use case is not “replace every document with a pretty diagram.” The practical use case is to build a few high-friction maps first, like service request intake, emergency routing, and core dependency chains, where a missed handoff can add 20 minutes of paging and guessing. (atlassian.com) The catch is that a visual map is only as good as the source material underneath it. If ownership fields are wrong, postmortems are missing, or architecture notes have drifted from production, the map can make bad information easier to navigate just as quickly as good information. (dynatrace.com) So the real idea in this demo is not mind maps as decoration. It is using artificial intelligence to turn scattered operational memory into something closer to a subway map, where a tired responder can see the lines, the transfers, and the dead ends before they start pulling the wrong lever. (mylens.ai)
