
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)
| Item | Detail |
|---|---|
| Format | Online, proctored, multiple choice |
| Duration | 90 minutes |
| Prerequisites | None |
| Price | US$250 exam only; US$495 with an annual training subscription |
| Validity | 2 years |
| Eligibility | 12 months to schedule and take the exam; two attempts (one retake) |
Read the official OTCA exam page and the OpenTelemetry documentation.
Domains and weights
| Domain | Weight | Sub-topics (from the Linux Foundation) |
|---|---|---|
| The OpenTelemetry API and SDK | 46% | Data model; composability and extension; configuration; signals (tracing, metrics, logs); SDK pipelines; context propagation; agents |
| The OpenTelemetry Collector | 26% | Configuration; deployment; scaling; pipelines; transforming data |
| Fundamentals of Observability | 18% | Telemetry data; semantic conventions; instrumentation; analysis and outcomes |
| Maintaining and Debugging Observability Pipelines | 10% | 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 setservice.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
traceparentheader. 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
| Week | Focus | Lab |
|---|---|---|
| 1 | Observability fundamentals, signals, semantic conventions, resources; API vs SDK; automatic instrumentation | Auto-instrument a small Python or Java app and send traces to Jaeger |
| 2 | Manual spans, attributes, events, metrics instruments, logs bridge, sampling, context propagation | Add manual spans for a checkout step; trace a call across two services |
| 3 | Collector: receivers, processors, exporters, pipelines, agent vs gateway, scaling; debugging; mocks | Run 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
- Add metrics depth with the Prometheus PCA and Kubernetes with KCNA.
- Learn observability in practice on our SRE course.
- See live DevOps and SRE jobs.
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.



