I Turned Obsidian Into a Live SOC Dashboard
The coffee shop Wi Fi portal had one of those fake-friendly names. “BeanHouse Guest.” Beige wallpaper. Soft jazz. The kind of network name that sounds safe because nobody bothered naming it something memorable.
My phone connected automatically.
Three minutes later, a pane inside Obsidian lit up red.
New device fingerprint. DNS requests to sketchy telemetry domains. A burst of connections to an IP block I already hated from another incident months earlier. Tiny little ripples. Nothing catastrophic. Just enough to make the room feel thinner.
That was the moment I realized most people are using note-taking apps backward.
They treat Obsidian like a filing cabinet.
I turned mine into a surveillance room.
Not against people. Against entropy. Against forgetting. Against the weird drifting fog that happens when your logs live in six different tools, your threat intel sits in browser tabs, and your memory becomes the weakest infrastructure component in the stack.
Once you wire live data into a vault, the notes stop being notes.
They start breathing.
The Problem With Most Personal SOCs
Most independent researchers and hobbyist defenders build the same graveyard eventually.
A Grafana dashboard nobody opens anymore.
A SIEM instance consuming half the RAM on a mini PC in the closet.
Twelve Python scripts named things like final-monitor-v2-real.py.
Random screenshots in Downloads.
Threat intel links scattered across Discord bookmarks and forgotten Telegram chats.
The information exists. Technically.
But it does not cohere.
A real SOC works because context accumulates. The IP matters because of the previous event. The domain matters because of the ASN. The process matters because someone remembers seeing it two months ago during another intrusion attempt. Human memory becomes part of the detection pipeline whether people admit it or not.
Obsidian accidentally solves part of this.
Backlinks. Graphs. Markdown. Local storage. Instant search. Embedded web views. Templating. Dataview queries. Plugins that probably should not exist but do anyway because somebody on GitHub slept four hours and entered a transcendental state.
The moment I understood that, the vault stopped being documentation.
It became infrastructure.
My Vault Started Looking Like A Ship Console
At some point the aesthetic drifted into something between submarine instrumentation and a conspiracy theorist’s garage wall.
Dark panes everywhere. Tiny glowing indicators. Embedded maps. Markdown notes crosslinked to active incidents. A page that tracks local network changes every fifteen minutes. Another page ingesting RSS feeds from CVE databases and exploit disclosure sites. A threat map shoved into the sidebar like an aquarium full of hornets.
It sounds excessive until you realize how much friction disappears when everything lives in the same environment.
An IP appears in a log.
You click it.
That opens a note containing previous sightings, ASN data, abuse reports, screenshots, timestamps, related domains, Shodan observations, packet captures, and your own exhausted commentary from 2:11 AM three weeks ago where you wrote:
“This thing smells industrial.”
That note links to another incident. Which links to another hostname. Which links to malware notes. Which links to a router exploit somebody posted to a Russian forum six months ago.
Suddenly your memory becomes navigable terrain instead of static storage.
Most cybersecurity tooling still treats information like isolated puddles. Obsidian turns it into fungal growth. Threads spreading underground.
The Weird Power Of Markdown In Security Work
People underestimate plain text because it looks primitive.
Plain text is immortal.
Every expensive enterprise dashboard eventually becomes archaeology. Proprietary formats rot. SaaS products get acquired by companies with names like NexaCore or Quantivault and suddenly the export function disappears into a premium tier. APIs change. Authentication breaks. A startup folds and takes your workflow down with it like a collapsing mine shaft.
Markdown survives everything.
That matters more than people think.
My vault has incident timelines from years ago sitting beside live scripts ingesting current network telemetry. Same interface. Same search engine. Same linking structure.
A note written half-asleep at a motel desk in 2024 can suddenly become relevant during recon in 2026 because the same infrastructure provider shows up again.
Memory is detection engineering.
Most people just never phrase it that way.
The Actual Setup
I did not build this as some clean enterprise architecture project. It accreted. Like barnacles on a rusted ship.
The first version was literally a Bash script dumping Wi Fi scan results into markdown tables every few minutes.
Then came Dataview.
Then Templater.
Then webhook integrations.
Then I started embedding live content directly into notes.
One pane tracks local network device changes through Python scripts feeding markdown files. Another watches RSS feeds from vulnerability trackers. I have a note that auto-updates with recent CISA advisories because manually checking those every day made me feel like a Victorian clerk sorting telegraphs.
One of the strangest additions ended up being simple colored callouts.
Yellow for suspicious.
Red for confirmed malicious.
Blue for infrastructure notes.
Green for devices I physically own.
You would be surprised how quickly visual memory attaches itself to color-coded threat intelligence. The brain likes symbols. Ancient hardware still hiding under modern skin.
The only real rule I followed was this:
Everything needed to degrade gracefully.
If plugins broke tomorrow, I still wanted readable notes.
If internet access vanished, I still wanted the archive.
If some dependency disappeared into GitHub oblivion after its maintainer got bored and started breeding shrimp or making ambient jungle music, the system should still function.
That constraint changed every design choice afterward.
SOC Tools Want You Looking Outward
This is the part vendors dislike discussing.
Most commercial security tooling assumes centralized environments. Corporate fleets. Teams. Tickets. Compliance reporting. Executive summaries nobody reads except during lawsuits.
Independent operators live differently.
Your laptop matters.
Your home router matters.
The weird Android device from 2018 matters.
The Raspberry Pi in the closet matters.
The café network matters.
The cheap chinese IoT device absolutely matters.
You are simultaneously the analyst, the help desk, the incident responder, and the idiot user clicking strange things at 1 AM because curiosity beat caution for half a second.
Traditional SOC interfaces often feel sterile for this kind of work. Too rigid. Too abstract.
Obsidian felt personal enough to adapt.
I could attach fragmented thoughts directly beside technical indicators. That ended up becoming unexpectedly useful.
“Traffic spike after connecting to train station Wi Fi.”
“Hostname resembles cheap smart camera OEM.”
“Possible overlap with malware infra from earlier scrape.”
Those observations rarely belong in enterprise tooling. They sound subjective. Informal.
But intuition leaves residue. Experienced analysts know this already. Sometimes a detail matters before you understand why it matters.
The vault became a place where incomplete thoughts could survive long enough to become evidence later.
Dataview Turned Notes Into Queries
This was the turning point.
Dataview sounds boring until you realize it effectively lets markdown behave like a database wearing a paper mask.
I started tagging infrastructure notes with metadata.
Country.
ASN.
Service type.
Threat category.
First seen.
Last seen.
Confidence level.
Then suddenly I could generate dynamic dashboards directly inside notes.
All IPs seen in the last week associated with VPS providers.
All incidents involving exposed Jenkins servers.
All notes tagged with “iot-chaos.”
All infrastructure connected to a specific malware family.
The vault stopped behaving like folders and started behaving like intelligence analysis software somebody accidentally hid inside a productivity app.
And because everything remained markdown underneath, it never felt trapped.
That matters psychologically too. Strange point, maybe, but true.
People investigate differently when the environment feels writable.
Traditional dashboards often feel ceremonial. Like you are interacting with sacred infrastructure owned by the company. Obsidian feels more like scribbling theories on the walls of an underground bunker while radios crackle in the background.
That freedom changes how experimental you become.
I Started Sleeping Better
Not because the system made me safer.
Because uncertainty became visible.
There is a difference.
A blinking router at 3 AM feels different when you have nowhere to place the event mentally. It becomes ambient paranoia. A loose thread in consciousness.
But once the event enters a structured system, once it gains timestamps and context and links and historical continuity, the fear changes shape.
It becomes operational.
That distinction matters more than people realize in cybersecurity.
Half the exhaustion comes from fragmented awareness. Tiny unresolved observations accumulating like static electricity in the nervous system.
The vault gave those fragments somewhere to go.
I think a lot of independent security people are quietly dealing with this exact psychological pressure. Too much information. Too many alerts. Too many disconnected observations floating around without narrative structure.
Humans need narrative structure.
Even defenders.
Especially defenders.
The Funniest Part Is That Obsidian Was Built For Productivity People
The original audience was probably students tracking philosophy notes or productivity maximalists inventing increasingly terrifying morning routines involving magnesium supplements and cold showers.
Now there are people wiring packet captures into it.
I have seen vaults used for malware analysis.
Physical penetration testing.
OSINT investigations.
RF experimentation.
Vehicle telemetry logging.
Bluetooth device tracking.
One person embedded a live aircraft tracker beside SDR analysis notes and weather radar feeds. The vault looked like NORAD after taking psychedelics in a RadioShack… Fucking groovy.
Another built an entire intrusion timeline system using canvas mode and local screenshots.
This is what happens when software stays flexible long enough.
People mutate it into things the creators never anticipated.
The internet used to produce more software like this. Open-ended tools. Things that invited adaptation instead of funneling everyone into the same sanitized workflow optimized for quarterly growth metrics.
Obsidian still has some of that older energy.
You can feel it.
There Are Risks Too
A vault like this becomes extremely sensitive very quickly.
People get excited about dashboards and forget operational security entirely.
Now you have local notes containing IP histories, screenshots, investigation timelines, infrastructure fingerprints, maybe even credentials if you are careless enough to let convenience rot your judgment.
Your note-taking app quietly becomes an intelligence archive.
That changes the threat model immediately.
I ended up isolating portions of the vault, encrypting sensitive directories, separating live telemetry ingestion from personal writing, and aggressively controlling plugin permissions.
Some plugins are incredibly powerful. Which also means they can become little supply-chain nightmares if abused.
The irony is hard to miss.
The SOC dashboard itself eventually becomes something worth defending.
Systems do this a lot. Build a tool to observe complexity and eventually the tool becomes part of the complexity.
Like building a lighthouse and realizing ships might start navigating by it.
The Interface Started Changing How I Think
This part is harder to explain cleanly.
When information becomes interconnected visually, your brain starts modeling systems differently.
You stop seeing incidents as isolated events.
Infrastructure clusters emerge.
Behavior patterns emerge.
Certain hosting providers start recurring like bad dreams.
You begin noticing the aesthetic fingerprints of attackers.
Some phishing kits feel visually related even before technical attribution exists. Certain admin panels carry the same design scars. Certain exposed systems have identical weird naming conventions because somewhere an installer script propagated across thousands of deployments like fungal spores.
The vault amplified pattern recognition simply because the information stayed near itself long enough.
Most browser tabs die before your brain can metabolize them properly.
Linked notes linger.
There is something deeply old-world about that. Like intelligence analysts pinning photographs to walls with cigarette smoke hanging in the air. Except now the wall updates itself every thirty seconds and occasionally executes Python.
A haunted corkboard with APIs.
I Don’t Really Separate Research From Memory Anymore
That line dissolved.
My vault contains threat intel beside journal fragments beside hardware notes beside weird observations from roadside motels with unstable Wi Fi.
At first I thought this was messy.
Now I think compartmentalization was the messier approach.
Real investigations are nonlinear. Human memory is nonlinear. Security work is full of emotional residue people pretend does not exist because professionalism likes clean surfaces.
But late-night investigations leave impressions behind.
The room temperature.
The music playing.
The feeling when an IOC suddenly matches something from months earlier.
Tiny details become anchors.
Obsidian accidentally preserves them.
And occasionally that matters.
Final Thoughts From The Glowing Cave Wall
Somewhere along the way, my note-taking app became the first thing I open during an incident and the last thing I close before sleep.
Not because it is the best SOC platform technically.
Because it became cognitively native.
That is rarer than people think.
Most software demands adaptation from the user. This setup adapted itself around the way my brain actually moves through investigations: messy, recursive, associative, suspicious, occasionally obsessive.
The dashboard keeps changing too. Every month another pane appears. Another script. Another stitched-together fragment of awareness.
It no longer feels like software exactly.
More like building a nervous system out of markdown and stubbornness.
And once you experience that, ordinary dashboards start feeling strangely mute.
Full vault template + live scripts are in Obsidian Operator OS linked below.
OBSIDIAN OPERATOR OS // TURN YOUR VAULT INTO A LIVE SOC DASHBOARDv2.6.1 // CLASSIFIED DOSSIER
Check out my other latest guides here-
OPENCLAW 2.0 – POWER USER EDITION2026 Operator’s Manual // For Advanced Operators Only
FLIPPER ZERO BLACK BOOK // 37 PAYLOADS THEY DON’T PUT IN THE DOCS
BadUSB Studio: 20 Rubber Ducky Scripts That Bypass Modern AV (2026 Edition)
