Skip to main content
Ameerpet, Hyderabad · Classroom & live online
Cloud Soft Solutions

OpenTelemetry Certified Associate (OTCA) Exam Guide 2026: API and SDK, Collector Pipelines, Context Propagation, 3-Week Lab Plan and 15 Questions

OTCA: a 90-minute online multiple-choice exam on OpenTelemetry, no prerequisites, valid 2 years. Four domains with weights (API and SDK is 46%), signals, API vs SDK, context propagation, OTLP, a Collector pipeline to recognise, a 3-week lab plan and 15 practice questions.

OpenTelemetry Certified Associate OTCA exam guide 2026, Cloud Soft Solutions
Last updated · 5 min read · 1,148 words

OpenTelemetry Certified Associate OTCA exam guide 2026, Cloud Soft Solutions

OTCA (OpenTelemetry Certified Associate) is the Linux Foundation and CNCF certification for OpenTelemetry, the open standard for collecting traces, metrics and logs from applications. OpenTelemetry is now the default way to instrument microservices for most observability tools, so it is worth knowing for DevOps, SRE, backend and platform roles. Nearly half the exam is about the API and SDK, a quarter is about the Collector, and the rest covers observability fundamentals and debugging pipelines.

This guide follows the official Linux Foundation exam page: the four domains with weights, the core concepts and components, a Collector configuration to recognise, a 3-week lab plan and 15 original practice questions.

Quick facts (Linux Foundation, November 2026)

ItemDetail
FormatOnline, proctored, multiple choice
Duration90 minutes
PrerequisitesNone
PriceUS$250 exam only; US$495 with an annual training subscription
Validity2 years
Eligibility12 months to schedule and take the exam; two attempts (one retake)

Read the official OTCA exam page and the OpenTelemetry documentation.

Domains and weights

DomainWeightSub-topics (from the Linux Foundation)
The OpenTelemetry API and SDK46%Data model; composability and extension; configuration; signals (tracing, metrics, logs); SDK pipelines; context propagation; agents
The OpenTelemetry Collector26%Configuration; deployment; scaling; pipelines; transforming data
Fundamentals of Observability18%Telemetry data; semantic conventions; instrumentation; analysis and outcomes
Maintaining and Debugging Observability Pipelines10%Context propagation; debugging pipelines; error handling; schema management

Core concepts

  • Signals: traces (a request's path through services, made of spans), metrics (numbers over time) and logs (timestamped events). OpenTelemetry links them through a shared trace ID.
  • API vs SDK: libraries call the API, which does nothing on its own. The application configures the SDK, which samples, processes and exports the data. This lets library authors instrument code without forcing a vendor.
  • SDK pipeline: for traces, a TracerProvider → span processors (batch or simple) → exporters; a sampler decides which traces to keep. Metrics use a MeterProvider with readers and exporters; logs use a LoggerProvider.
  • Resource: attributes describing what produced the data, such as service.name, version and host. Always set service.name.
  • Semantic conventions: standard attribute names (for example http.request.method) so every tool understands the data.
  • Context propagation: passing trace context between services, usually in the W3C traceparent header. If one service drops it, the trace breaks into pieces.
  • Instrumentation: zero-code (automatic agents for Java, Python, .NET, Node.js) or manual (creating spans and metrics in code). Most teams start automatic and add manual spans for business steps.
  • OTLP: the OpenTelemetry Protocol over gRPC (port 4317) or HTTP (port 4318).

The Collector

The Collector is a separate process that receives, processes and exports telemetry. Deploy it as an agent (sidecar or DaemonSet next to apps) and/or a gateway (a central, scalable service). Pipelines are defined per signal.

receivers:
  otlp:
    protocols:
      grpc: { endpoint: 0.0.0.0:4317 }
      http: { endpoint: 0.0.0.0:4318 }
processors:
  memory_limiter: { check_interval: 1s, limit_percentage: 80 }
  batch: {}
  attributes:
    actions:
    - { key: user.email, action: delete }    # drop personal data
exporters:
  otlp:
    endpoint: tempo.observability:4317
  prometheus:
    endpoint: 0.0.0.0:8889
  debug: { verbosity: basic }
service:
  pipelines:
    traces:  { receivers: [otlp], processors: [memory_limiter, attributes, batch], exporters: [otlp] }
    metrics: { receivers: [otlp], processors: [memory_limiter, batch], exporters: [prometheus] }

Put memory_limiter first and batch near the end. A component that is defined but not listed in a pipeline does nothing. Use the debug exporter and the Collector's own metrics when data goes missing.

3-week lab plan

WeekFocusLab
1Observability fundamentals, signals, semantic conventions, resources; API vs SDK; automatic instrumentationAuto-instrument a small Python or Java app and send traces to Jaeger
2Manual spans, attributes, events, metrics instruments, logs bridge, sampling, context propagationAdd manual spans for a checkout step; trace a call across two services
3Collector: receivers, processors, exporters, pipelines, agent vs gateway, scaling; debugging; mocksRun the Collector in Docker, drop a sensitive attribute, export to two back ends; book the exam

15 practice questions with answers

These are original questions written for this guide, not exam questions.

1. Name the three main OpenTelemetry signals.
Traces, metrics and logs.

2. What is one unit of work inside a trace called?
A span.

3. A library only depends on the OpenTelemetry API, and the app doesn't configure an SDK. What is exported?
Nothing; the API is a no-op without an SDK.

4. Which resource attribute should every service set?
service.name.

5. Which header carries trace context between services by default?
The W3C traceparent header.

6. A trace shows the frontend and backend as two separate traces. What is the likely cause?
Context propagation is broken (the header isn't passed or extracted).

7. What are the default OTLP ports for gRPC and HTTP?
4317 and 4318.

8. Which span processor should production use, simple or batch?
Batch, for efficiency.

9. Traffic is huge and storing every trace is too expensive. What do you configure?
Sampling (head sampling in the SDK, or tail sampling in the Collector).

10. Name the three kinds of Collector pipeline components.
Receivers, processors and exporters.

11. Where do you remove a personal-data attribute before it leaves your network?
In a Collector processor (for example attributes or transform).

12. What is the difference between agent and gateway deployment of the Collector?
An agent runs next to the app (sidecar or per node); a gateway is a central service that receives from many agents and scales horizontally.

13. Why put memory_limiter first in the processor list?
So the Collector refuses data before running out of memory under load.

14. Why do semantic conventions matter?
Standard attribute names let dashboards, queries and back ends understand data from any service.

15. Data reaches the Collector but not the back end. What is a quick first check?
Add the debug exporter to the pipeline and check the Collector's logs and internal metrics for export errors.

After OTCA

Cloud Soft Solutions in Ameerpet, Hyderabad teaches DevOps, SRE and observability with real-time projects. See the APEX program and all courses.

📞 Call +91 96660 19191 · WhatsApp · Flat No. 513, 5th Floor, Nilagiri Block, Aditya Enclave, Ameerpet, Hyderabad

Frequently Asked Questions

What is the OTCA exam?
The Linux Foundation and CNCF OpenTelemetry Certified Associate: an online, proctored, multiple-choice exam on OpenTelemetry.

How long is the OTCA exam?
90 minutes.

Which OTCA domain has the most weight?
The OpenTelemetry API and SDK at 46%, followed by the OpenTelemetry Collector at 26%.

Does OTCA have prerequisites?
No. There are no prerequisites.

How many attempts do I get?
Two attempts: the first exam and one retake.

What ports does OTLP use?
4317 for gRPC and 4318 for HTTP by default.

Share𝕏inf✉
EnrollWhatsAppCall us