OTCA course and practice exam: OpenTelemetry Certified Associate
This OTCA course has 30 video lessons and 84 graded labs, and its OTCA practice exam follows the official exam objectives: a 20-question sampler free with an account, the full question bank and timed mock exams with Pro.
OpenTelemetry fundamentals, API and SDK, and the Collector
Prepares you for OTCA: observability fundamentals, the OpenTelemetry API and SDK, the Collector, and maintaining and debugging pipelines.
Intermediate · 3 hours · 30 lessons · 94 labs
OTCA exam guide
The OTCA exam (OpenTelemetry Certified Associate, by CNCF / The Linux Foundation): 90 minutes; pass mark: 75%; cost: USD 250 (includes one retake); USD 495 bundled with the course.
- Format: Online, proctored, multiple-choice
- Duration: 90 minutes
- Questions: not published
- Pass mark: 75%
- Cost: USD 250 (includes one retake); USD 495 bundled with the course
- Valid for: 2 years
- Delivery: Online, proctored (PSI)
- Prerequisites: None
Exam domains and weights
- Fundamentals of Observability: 18%
- The OpenTelemetry API and SDK: 46%
- The OpenTelemetry Collector: 26%
- Maintaining and Debugging Observability Pipelines: 10%
A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
10 OTCA sample questions with answers: free to read, no account needed.
Common questions
How long is the OTCA exam?
The OTCA exam lasts 90 minutes.
What is the OTCA passing score?
The pass mark is 75%.
How much does the OTCA exam cost?
USD 250 (includes one retake); USD 495 bundled with the course.
Is there a free OTCA practice test?
Yes. A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
Source: OTCA exam page (Linux Foundation Training), domains, weights and competencies (CNCF / The Linux Foundation), checked 2026-10-03.
Who it is for
Intermediate level.
For developers, SREs and platform engineers preparing for the OpenTelemetry Certified Associate exam, who collect traces, metrics and logs from their services.
What you don't need yet:
- No previous OpenTelemetry experience
- No servers or cloud account: labs use recorded real telemetry
- No Python: one lesson shows a few lines of tracing code, explained
What helps:
- A rough idea of how services call each other over HTTP
- Reading short YAML: most labs fill in or fix a YAML file
No formal prerequisites. The courses under "Take first" cover what helps.
Take first:
- Prometheus Certified Associate (PCA) Exam Prep — Intermediate
Take next:
Learning paths:
Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.
What this exam proves, and what it doesn't
OTCA is an online, proctored, multiple-choice exam: passing shows you know OpenTelemetry's concepts and parts. It doesn't test hands-on skill or replace running it in production; our graded labs use recorded real telemetry.
Exam objectives this course teaches
OpenTelemetry Certified Associate (OTCA)
- Fundamentals of Observability (18% of the exam): Telemetry Data; Semantic Conventions; Instrumentation; Analysis and Outcomes
- The OpenTelemetry API and SDK (46% of the exam): Data Model; Composability and Extension; Configuration; Signals (Tracing, Metric, Log); SDK Pipelines; Context Propagation; Agents
- The OpenTelemetry Collector (26% of the exam): Configuration; Deployment; Scaling; Pipelines; Transforming Data
- Maintaining and Debugging Observability Pipelines (10% of the exam): Context Propagation; Debugging Pipelines; Error Handling; Schema Management
Labs
94 labs, 84 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.
What is free
Start free: First module free with an account. Pro: Every course, lab, handbook, practice exam and certificate.
- Pro monthly — $29 a month. Every course, lab, handbook, practice exam and certificate
- Pro yearly — $249 a year. Every course, lab, handbook, practice exam and certificate
Course outline
Start Here
- Fifteen Traces For Six Bookings: Where Context Was Lost (3 labs): You can find where a distributed trace breaks from its root spans and the propagation headers each service received, and describe the OTCA exam and its four domains.
- Ninety Minutes, No Question Count: Exam Strategy (3 labs): You can plan the OTCA exam in minutes per domain, work it in three passes, and spot the default and precedence traps its questions are built on.
Fundamentals
- The Three Signals: Logs, Metrics And Traces (3 labs): You can say what a log, a metric and a trace each answer well, what each costs, and which one to reach for when something is wrong.
- Two Names For One Fact: Semantic Conventions And Resources (3 labs): You can check attribute names against the semantic conventions registry, read a resource and its schema URL, and use OTEL_SEMCONV_STABILITY_OPT_IN to move instrumentation to the stable HTTP names.
- Traces From A Script Nobody Touched: Instrumentation Approaches (4 labs): You can compare zero-code, library and code-based instrumentation, say what each captures, and find which libraries an agent can instrument.
- A Warning With An Address: Correlating Signals (3 labs): You can correlate metrics, traces and logs through shared IDs and resources, localise a failure from a metric to a span, and explain why server spans for 4xx answers stay unset.
- Fundamentals Sprint: One Declined Card (4 labs): You can answer exam-style questions across the fundamentals domain: signals, semantic conventions, instrumentation approaches, and analysis from metric to trace to log.
API And SDK
- A Library That Traces Nothing, Safely: API, SDK And Extension (3 labs): You can explain the API and SDK split, what the API does with no SDK installed, and how the SDK is composed from providers and plug-ins such as samplers, processors, exporters and ID generators.
- Fifty Two Spans, Four Requests: The Trace Data Model (3 labs): You can read spans in OTLP/JSON: the resource, scope and span nesting, span identity and timing fields, kinds, statuses, events, links and the remote-parent flags.
- Three Hundred Milliseconds In One Place: Tracing In Code (3 labs): You can create nested spans with a tracer, name them with low cardinality, set attributes and error status, record exceptions, and find untraced work from the gaps between parent and child spans.
- Four Bookings Or Two: Instruments And Temporality (4 labs): You can choose counters, up-down counters, histograms and gauges, predict their default aggregations, and explain cumulative and delta temporality and who chooses it.
- A Histogram That Could Not Answer: Views (3 labs): You can configure metric views to change bucket boundaries, rename metrics, drop instruments and limit attribute keys, and explain how histogram buckets and instrument advice affect what a histogram can answer.
- Keep Your Logger: The Logs Bridge And Log Records (3 labs): You can explain the Logs Bridge API and its role for appenders, set up a logger provider pipeline, and read a log record's timestamps, severity, body, attributes and trace context.
- Fifty Five Characters: Trace Context And Baggage (4 labs): You can parse and validate W3C traceparent and baggage headers, explain inject, extract and propagator configuration, and predict when a header continues or restarts a trace.
- Six Out Of Twelve At One In Four: Samplers (3 labs): You can explain head sampling decisions, configure AlwaysOn, AlwaysOff, TraceIdRatioBased and ParentBased samplers in code and with OTEL_TRACES_SAMPLER, and predict ratio decisions from trace IDs.
- The Spans Of A Job That Ended Too Soon: SDK Pipelines (4 labs): You can compose SDK pipelines from processors, readers and exporters, choose batch or simple processing, tune the batch span processor, and flush and shut down providers before exit.
- Nine Lines, Five Bugs: Configuring The SDK (3 labs): You can configure an SDK in code, by OTEL_ environment variables and by OTEL_CONFIG_FILE, and apply the precedence rules for service name and OTLP endpoints, ports and protocols.
- Six Launches, No Code Changes: Language Agents (2 labs): You can explain what a zero-code agent configures and patches, set it by flags or OTEL_ variables, and predict which spans and trace headers each setting produces, in Python and through the Kubernetes Operator.
- API And SDK Sprint: Fourteen Predictions (3 labs): You can answer exam-style questions across the API and SDK domain: instruments and their data types, propagator headers, sampler and batch configuration, and the traps those questions use.
Collector
- Sixty Two New Names: Collector Components And Pipelines (2 labs): You can name the five kinds of Collector component, read service pipelines and component IDs, order processors, choose a distribution, and recognise the 0.162 component renames such as otlp to otlp_grpc.
- Validated And Deaf: Checking A Collector Config (4 labs): You can run and read otelcol validate, explain what it checks, and find what it passes, such as an unknown key under the OTLP receiver's protocols.http in 0.162, an unused component and a deprecated name.
- Fifty Five In, Fifty Two Out: Transforming Data (4 labs): You can drop, edit, hash and rename telemetry in the Collector with the filter, attributes, resource and transform processors, write simple OTTL statements, and verify the result from the output and internal metrics.
- Which Node Was It? Collector Deployment Patterns (3 labs): You can choose between no Collector, agent, gateway and agent plus gateway, place work in the right tier, connect an agent to a gateway, and name the Operator modes for each pattern.
- Two Replicas, Half A Trace: Scaling The Collector (3 labs): You can scale stateless Collectors with replicas, explain why tail sampling needs every span of a trace in one place, and route by trace ID with the load_balancing exporter (formerly loadbalancing).
- Collector Sprint: Sixteen Predictions (3 labs): You can answer exam-style Collector questions on pipelines and signals, processor behaviour, component names, deployment tiers and tail sampling at scale.
Maintaining And Debugging
- Fifty Four In, Two Out: Debugging A Pipeline (3 labs): You can debug a Collector pipeline with its internal metrics, logs, the debug exporter and extensions, locate the step where data is lost, and tell a refusing receiver from a failing exporter.
- Failed Twice, Flushed Fine: Error Handling And Schemas (4 labs): You can explain how the SDK and the Collector handle export errors (no exceptions into the app, retry for transient errors, drop for permanent ones, queues and timeouts) and manage renames with schema URLs and the schema processor.
- Maintenance Sprint: Symptoms First (3 labs): You can answer exam-style questions on maintaining and debugging pipelines: diagnose broken propagation, missing signals, transient and permanent export errors, and untranslatable telemetry from their symptoms.
Mock And Review
- Forty Four Of Sixty: The Mock And What It Tells You (2 labs): You can sit a mock under exam conditions, break the score down by domain weight, turn every miss into a rule and a lesson to replay, and judge when your margin is enough to book.
- The Evening Before: Final Review (2 labs): You can recall the defaults, ports and renamed components and attributes the exam tests, trace one request through all four domains, and eliminate wrong options by layer, default, version and relevance.