Systems, Stories, and Signals
Why I’m Telling these Stories
If you’ve spent any amount of time working with modern systems you’ve probably run into the same problem I have: We’re not short on data – we’re short on understanding.
This is especially true when it comes to monitoring and observability solutions.
Somewhere along the way, we got really good at collecting metrics, logs, and traces… and a lot less good at helping people actually make sense of them.
And that gap—the one between systems and the humans trying to use them? That’s where I’ve always spent most of my time.
Why This Series Exists
This series is my attempt to explore a simple idea:
Technology is only as valuable as it is understandable.
Over the next set of posts, I’m going to dig into how complex systems become:
- Understandable
- Usable
- Actually helpful
Sometimes that’ll look like:
- Breaking down how a specific piece of my observability stack works
- Explaining a concept in plain English (with the occasional analogy)
- Sharing “stories from the field” learned from building things the “hard way” in a home lab
Other times it’ll lean more into:
- Product thinking
- Community strategy
- Documentation and user education
- Why some tools succeed while others… don’t
The Through-Line (a.k.a. What This Is Really About)
If there’s a common thread, it’s this:
I like helping people connect the dots.
I’ve spent a good chunk of my career:
- Building systems
- Supporting systems
- Explaining systems
- Occasionally fixing systems at 2 AM
And across all of that, one thing keeps showing up:
The hardest problems usually aren’t necessarily technical: they’re translation problems.
- Engineers build powerful things
- Users try to use them
- And somewhere in between, clarity gets lost
This series lives in that “somewhere in between.”
What You Can Expect
The posts in this series will fall into a few buckets:
Building things 🔧
Real projects from my home lab (observability stack, logging pipelines, etc.)—with explanations focused on why, not just how.
Thinking about things 🧠
Perspectives on product design, observability, and the reality of how people actually use technology.
Explaining things 🧭
Breaking down complex concepts into something approachable and useful—especially for folks who didn’t build the system in the first place.
Why I’m Doing This Now
Lately, I’ve been thinking more about the intersection of:
- Product Management
- Community
- Developer Relations
Not as separate roles, but as different ways of solving the same problem:
Helping people get value from technology.
This series is a way for me to explore that space more intentionally—and share what I’ve learned (and am still figuring out) along the way.
If You’re Following Along…
This is very much a “learn in public” kind of effort. Some posts will be polished. Some will be more exploratory. All of them will be honest. There will be successes, there will be failures, but the overarching theme is there’s almost always a story to tell.
If you’re into:
- Observability
- Making sense of complex systems
- Better dashboards, docs, and user experiences
- Or just figuring out why things work the way they do
…you’ll probably find something here.
One Last Thing
This is the kind of work I enjoy most – making complex systems easier to understand and more useful for the people who rely on them. My passion has always been turning complexity into simplicity – even when we have to gloss over some of the finer details. End users deserve our respect and understanding, not just our solutions.
If that’s something you’re working on too, I’d love to connect. I’m all over the place and am happy to have a chat.
Series Link 📌
You can follow the full series here: 👉 Systems, Stories, and Signals