At small scale any log store works; at scale the invoice decides, not the feature list. The four dominant logging backends make fundamentally different storage bets that fix their cost-per-GB and what queries are even fast. A deep dive on the index-everything camp versus the cheap-storage camp, and the ingest discipline that beats all of them.
Observability
-
Modern Logging Architecture: Loki, Splunk, Elasticsearch, ClickHouse, and the Cost-Per-GB That Decides Everything -
Linux Performance Analysis Systematic Linux performance analysis: the USE method, CPU profiling with perf and flamegraphs, memory pressure with vmstat and /proc/meminfo, I/O profiling with iostat and blktrace, dynamic tracing with bpftrace one-liners, and strace for syscall inspection.
-
Grafana + Prometheus Homelab Stack Building a full observability stack for the homelab: Prometheus with node exporter, cAdvisor, blackbox exporter, and SNMP exporter, Alertmanager for notifications, Grafana with provisioned dashboards, and long-term storage with Thanos or Mimir.
-
SLO-as-Code with Sloth and Pyrra: Multi-Window Burn-Rate Alerts, Error Budget Policy, and Grafana Dashboards A deep-dive into SLO-as-code workflows using Sloth v0.16 and Pyrra v0.10: complete YAML specs, generated PrometheusRules, multi-window multi-burn-rate alerting math, Grafana integration, and the organizational error budget policy conversation.
-
OpenSearch in Production Index lifecycle management, shard sizing decisions, dashboards, alerting, k-NN neural search, the OpenSearch vs Elasticsearch question in 2026, and running OpenSearch on Kubernetes.
-
OpenTelemetry in Practice: Tracing, Metrics, and Logs Without Vendor Lock-In A practical guide to OpenTelemetry: instrumenting real services with the SDK, running the Collector as a telemetry pipeline, exporting traces to Grafana Tempo, metrics to Prometheus, logs to Loki, and understanding context propagation and baggage.
-
eBPF for Observability: Writing Your First Program What eBPF actually is, how the verifier and JIT compiler work, bpftrace one-liners for immediate production insight, writing a real tracing program in C with libbpf, and the production tools built on top of it — Cilium, Pixie, and Parca.
-
BPF Performance Tools Tour: bcc, bpftrace, and libbpf A tour of the eBPF performance tooling that has reshaped Linux observability — bcc, bpftrace, and libbpf — with practical one-liners and scripts for tracing kernel and userspace events at production scale.
-
Flamegraphs: Reading and Generating How to read and generate flamegraphs — the visualization that turned profiling into something engineers enjoy — covering CPU, off-CPU, and differential flamegraphs, and the perf and eBPF pipelines that produce them.
-
perf: Linux's Best Profiler A practical guide to perf, the profiler that actually shows you what the CPU is doing — sampling, hardware counters, call graphs, and the workflows that feed flamegraphs — written for engineers starting serious Linux performance work.
-
The USE and RED Methods: Systematic Performance Investigation Two checklists that turn flailing performance investigations into systematic ones — Brendan Gregg's USE method for resources and the RED method for request-driven services — and when to reach for each.
-
SLOs in Practice: Beyond the Math Burn rate alerts, multi-window multi-burn-rate alerting, error budget policies, tools like Sloth and Pyrra, and the organizational challenges of getting teams to actually own their SLOs.
-
Perses: The Open Dashboarding Standard Perses is a CNCF sandbox project that treats dashboards as code — versioned in Git, validated in CI, deployed as Kubernetes CRDs. Here's what it is, how it works, and when to use it.
-
Pyroscope: Continuous Profiling in Production Pyroscope brings always-on profiling to production systems — flame graphs for CPU hotspots, memory leaks, and goroutine issues, correlated with your traces and metrics.
-
Alloy: The OpenTelemetry Collector from Grafana Grafana Alloy replaces Grafana Agent, Grafana Agent Flow, and promtail with a single programmable OpenTelemetry collector. Here's how it works, how to deploy it, and how to build real pipelines with it.
-
ClickHouse for Observability: Logs, Metrics, and Traces at Scale How ClickHouse's columnar storage architecture makes it the ideal backend for logs, metrics, and traces at scale — replacing Elasticsearch with a fraction of the resources.
-
Designing for Observability: Building Applications You Can Actually Debug A practical guide to designing applications that are easy to debug in production — structured logging with trace IDs, meaningful metrics, health endpoints, graceful degradation, and the patterns that separate systems you can reason about from ones you can only guess at.
-
Monitoring Your Homelab with Prometheus and Grafana: The Complete Stack Build a production-grade homelab monitoring stack from scratch: Prometheus with Node Exporter and cAdvisor, Grafana dashboards, alerting with Alertmanager, and long-term storage with VictoriaMetrics.
-
OpenTelemetry: One Instrumentation to Rule Them All A deep dive into OpenTelemetry: the data model for traces, metrics, and logs; auto-instrumentation for Go, Python, and Node.js; building a Collector pipeline; and exporting to Jaeger, Prometheus, and Loki.
-
VictoriaMetrics: Prometheus at Scale How VictoriaMetrics handles Prometheus at scale — architecture deep dive, vminsert/vmselect/vmstorage clustering, MetricsQL extensions, remote_write migration, and achieving 10x better storage efficiency.
-
Distributed Tracing with Tempo and Grafana: From Zero to TraceQL A comprehensive guide to distributed tracing with Grafana Tempo—covering trace storage internals, TraceQL queries, correlating traces with logs and metrics, and production deployment patterns.
-
eBPF for Observability A practical guide to using eBPF for deep observability — tracing system calls and kernel events with bpftrace, profiling applications with BCC tools, and building network visibility with Cilium.
-
Network Observability with Cilium and Hubble: Complete Visibility Into Your Kubernetes Network A comprehensive guide to Cilium and Hubble — installing the eBPF-based CNI, capturing flow logs, debugging network policies, building Grafana dashboards, and achieving complete network visibility in Kubernetes.
-
OpenTelemetry in Practice: Instrumentation, the Collector, and Connecting to Your Observability Stack A hands-on guide to OpenTelemetry: auto-instrumentation and manual SDK usage across Python, Go, and Node.js; building a production Collector pipeline with processors and exporters; and wiring traces, metrics, and logs together in Grafana.
-
Service Meshes with Istio and Linkerd A practical guide to service meshes — what they are, when you actually need one, and how to use Istio and Linkerd for mTLS, traffic splitting, observability, and fault injection.
-
SLOs and Error Budgets: The Engineering Discipline Behind Reliable Services A practical guide to defining Service Level Objectives, calculating error budgets, building multi-window burn rate alerts, and running SLO reviews that drive real reliability improvements.
-
Time-Series Data with InfluxDB and TimescaleDB A practical guide to modelling, storing, and querying time-series data with InfluxDB and TimescaleDB — including retention policies, downsampling, and real-world sensor data patterns.
-
Alerting That Doesn't Burn You Out: Fighting Alert Fatigue and Building Sane On-Call Alert fatigue is quietly destroying on-call teams — learn how to audit and redesign your alerting, write runbooks that actually help, configure Alertmanager intelligently, and build an on-call rotation that engineers don't dread.
-
Loki for Log Aggregation: Ship, Query, and Correlate Your Logs A complete technical guide to Grafana Loki — covering architecture, log shipping with Promtail and Alloy, LogQL queries, Grafana integration, alerting rules, and label strategy for homelabbers and DevOps engineers adding logs to their observability stack.
-
Profiling Applications: Finding Bottlenecks in Go, Python, and Node.js Stop guessing why your application is slow. This guide covers systematic profiling tools and techniques for Go (pprof), Python (cProfile, py-spy, line_profiler), and Node.js (clinic.js, V8 profiler) so you can find the actual bottleneck and fix it with confidence.
-
The Prometheus + Grafana Stack: Metrics, Alerting, and Dashboards A deep technical guide to building production-grade observability with Prometheus and Grafana — covering metrics collection, PromQL queries, alerting rules, Alertmanager routing, and dashboard construction for homelabbers and DevOps engineers.
-
Uptime Kuma: Self-Hosted Status Pages and Alerting Done Right A practical guide to Uptime Kuma — the self-hosted uptime monitoring tool with a beautiful UI, 90+ notification integrations, and built-in status pages that replaces UptimeRobot, StatusCake, and Pingdom for homelabbers and DevOps engineers.
-
Monitoring and Observability: From the Golden Signals to a Complete Self-Hosted Stack What to measure and why — RED, USE, the Four Golden Signals, percentiles, and error budgets — then a production-grade, self-hosted stack built on Prometheus, Grafana, Loki, and Alertmanager. Full Docker Compose, configs, alert rules, dashboards, and integration tips for any VPS or homelab.
-
Systematic Debugging Strategies Debugging is not guessing with extra steps. It is a discipline of forming hypotheses, designing experiments that can disprove them, and binary-searching the gap between a working state and a broken one. This is a working engineer's field guide to reproduction, bisection, observability-driven debugging, concurrency and heisenbugs, production debugging without a debugger, and turning every fixed bug into a test that keeps it dead.
-
Effective Log Management Strategies Logs are cheap to produce and expensive to keep, and most teams get the economics backwards. A practical guide to log management as a discipline: structured logging, log levels that mean something, the cost-and-cardinality model, what to sample or drop before ingest, retention and tiering, PII redaction, and how logs fit alongside metrics and traces.