Why your OpenTelemetry setup is probably generating useless spans
Most teams instrument everything and understand nothing. A practical guide to designing spans that actually help you debug production issues.
Observability Consulting
We help engineering teams see what's actually happening in production. Before it becomes a problem.
We design, implement, and optimize observability stacks so your team can debug faster and prevent incidents.
Observability architecture & OpenTelemetryDistributed tracing across microservicesProduction debugging & incident responseJVM performance & reliability
Background
15+ years building and debugging production systems
I've spent most of my career helping engineering teams see what's actually happening in production. I specialize in debugging latency issues, designing telemetry pipelines, and moving from reactive firefighting to proactive observability.
My work spans fintech, e-commerce, and platform engineering, with hands-on experience in OpenTelemetry, the JVM ecosystem, Grafana, Elasticsearch, and most major APM platforms. I don't sell tools — I help you understand your systems.
15+
Years in production systems
OTel
OpenTelemetry specialist
JVM
Deep JVM expertise
DS
Distributed systems focus
How I help
Concrete outcomes, not slide decks
Every engagement starts with understanding your system and ends with measurable improvements. Here's what that looks like.
Observability Audit
I review your current metrics, logs, and traces setup. I identify gaps in coverage, noisy signals, and missing correlations — then deliver a prioritized report with concrete recommendations.
Outcome
Clear picture of what's working, what's noise, and what's missing
Architecture & Instrumentation Design
I design observability architectures for distributed systems — from OpenTelemetry instrumentation to backend storage and visualization. I work with your stack, not against it.
Outcome
A telemetry architecture that scales with your system
Production Debugging
When something breaks and nobody can figure out why, I help. I bring deep experience in tracing latency issues, memory leaks, and cascading failures across distributed services.
Outcome
Faster root cause identification and resolution
Performance & Reliability
I analyze your system's runtime behavior to find bottlenecks, resource contention, and reliability risks. JVM profiling, load analysis, SLO definition — whatever the system needs.
Outcome
Reduced latency, improved uptime, clear SLOs
Team Enablement
I run hands-on workshops on observability practices, OpenTelemetry instrumentation, and effective debugging. Your team learns to own their telemetry — not just consume dashboards.
Outcome
A team that can instrument, debug, and iterate independently
How I work
Straightforward process, no surprises
I keep things simple. Every engagement follows a clear structure so you know exactly what to expect.
01
Understand the system
I start by reading your architecture, talking to the team, and reviewing existing telemetry. No assumptions.
02
Identify blind spots
I map what you can see versus what you need to see. Most teams have more data than insight — the gap is usually in correlation, not collection.
03
Design the solution
I propose changes that fit your stack, your team, and your constraints. No vendor lock-in, no unnecessary complexity.
04
Implement and validate
I work alongside your engineers to implement changes and verify they actually improve visibility. The goal is a system the team can own and evolve.
Writing
Insights on observability
Practical thinking on distributed systems, observability, and production engineering. No hype, just things I've learned the hard way.
The hidden cost of correlation: when tracing creates more problems than it solves
Distributed tracing is powerful, but trace propagation across async boundaries and message queues can introduce subtle issues. Here's how to handle them.
SLOs are not SLAs: how to define reliability targets your team will actually use
The difference between a reliability target that drives engineering decisions and one that collects dust in a wiki page.
Debugging JVM memory pressure in containerized environments
Container memory limits and JVM ergonomics don't always agree. A deep dive into diagnosing and fixing OOM kills, GC storms, and off-heap memory leaks.
Have questions or need specialized consulting?
If you have questions about the platform or are looking for technical consulting in observability, architecture, or OpenTelemetry, write to us directly.
Contact form
Fill the fields and we'll get in touch
We respond within 24 hours. You can also start for free on your own anytime.