What you'll learn:
- Prepare for the OpenTelemetry Certified Associate (OTCA) exam with structured, domain-aligned lessons
- Understand Observability fundamentals: signals, monitoring vs observability, reliability metrics & SRE principles
- Instrument Java & Python applications hands-on using zero-code, code-based & library-based approaches
- Master all four OpenTelemetry signals: metrics, traces, logs and baggage — with working code examples
- Understand the OpenTelemetry API/SDK split, plugin interfaces, samplers and SDK composability
- Configure the OpenTelemetry Collector: receivers, processors, exporters, extensions and pipelines
- Learn Collector deployment patterns: Agent, Gateway, Kubernetes DaemonSet, Sidecar and scaling strategies
- Debug observability pipelines: context propagation failures, data loss and schema management
- Explore OpenTelemetry Demo to see production-scale instrumentation in action
Build real OpenTelemetry skills you can apply from day one - from observability fundamentals to Collector configuration, with OTCA prep included.
OpenTelemetry has become the industry standard for observability and with the Linux Foundation's OTCA certification, there's now a formal way to prove your expertise. This course is built to help you do both understand OpenTelemetry deeply and prepare for the certification exam with confidence.
Designed for developers, SREs, and operations engineers with little to no prior observability experience, this course takes you from the fundamentals all the way through to the architecture and configuration knowledge the OTCA exam expects.
What You'll Learn
Observability Foundations: What observability is, how it differs from monitoring, reliability metrics (MTTD, MTTR, MTBF), and SRE principles including SLIs, SLOs, and error budgets
OpenTelemetry Core Concepts: The API/SDK split, the three instrumentation approaches (zero-code, code-based, and libraries), and how they fit together
All Four Signals, Hands-On: Metrics, traces, logs, and baggage — implemented from scratch in both Java and Python using a purpose-built demo app
SDK Architecture & Composability: Providers, plugin interfaces, samplers, processors, exporters, and the three ways to configure the SDK
Semantic Conventions & OTLP: The standards that make OpenTelemetry data portable across tools and vendors
The OpenTelemetry Collector: Receivers, processors, exporters, extensions, pipelines, deployment patterns (Agent, Gateway, Kubernetes DaemonSet/Sidecar), and scaling strategies
Debugging & Maintenance: Context propagation failures, Collector pipeline debugging, error handling, data loss prevention, and schema management
Emerging Signals: A preview of Profiling and where OpenTelemetry is heading next
Hands-On From the Start
You'll work with two real applications throughout the course:
hello-telemetry: A simple Java + Python + MySQL app I built specifically for this course, so you can see every instrumentation concept in isolation, without distraction
OpenTelemetry Demo: The official community-maintained microservices demo, so you can see OpenTelemetry at production scale
Every concept is paired with hands-on exercises, and the code is available on GitHub so you can follow along at your own pace.
Who This Course Is For
Developers who want to instrument their applications properly and understand what happens under the hood
SREs and operations engineers responsible for observability pipelines and the OpenTelemetry Collector
Anyone preparing for the OpenTelemetry Certified Associate (OTCA) exam
Teams evaluating OpenTelemetry for adoption in their organisation
Ready to get started? Enrol today and take the first step towards mastering OpenTelemetry and earning your OTCA certification.
