PracticeVideosBlogFlashcardsEspañol
All Practice Exams

Free Practice Questions for LF Observability

Exam-style questions and explanations by OpenExamPrep.

✓ No registration✓ No credit card
100+ Questions
100% Free

Loading practice questions...

Same family resources

Explore More Linux Foundation Certifications

Continue into nearby exams from the same family. Each card keeps practice questions, study guides, flashcards, videos, and articles in one place.

Linux Foundation Certified System Administrator (LFCS)

Practice Questions

Besu Certified Professional (BCP)

Practice Questions

Certified Backstage Associate (CBA)

Practice Questions

Certified Open Source Developer for Enterprise (CODE)

Practice Questions

Cilium Certified Associate (CCA)

Practice Questions

FCFP FINOS Certified FDC3 Practitioner

Practice Questions
Exam Review

Key Facts: LF Observability Exam

60

Exam Questions

Linux Foundation

75%

Passing Score

Linux Foundation

90 min

Exam Duration

Linux Foundation

$250

Exam Fee

Linux Foundation

5

Content Domains

LF Observability

2 years

Certification Validity

Linux Foundation

The LF Observability Fundamentals exam has 60 multiple-choice questions in 90 minutes with a 75% passing score. It covers observability fundamentals (20%), OpenTelemetry (25%), Prometheus and PromQL (25%), logging and tracing (20%), and SLO/SLI plus eBPF observability (10%). Aligns with LFS148 (OpenTelemetry) and LFS241 (Prometheus) curricula.

Sample LF Observability Practice Questions

Try these sample questions to review concepts for the LF Observability exam. Each question includes a detailed explanation. Start the interactive quiz above for the full 100+ question experience with AI tutoring.

1Which three signals are commonly referred to as the 'three pillars of observability'?
A.Metrics, logs, and traces
B.Alerts, dashboards, and runbooks
C.CPU, memory, and disk
D.Errors, warnings, and info
Explanation: The three pillars of observability are metrics (numeric measurements over time), logs (timestamped event records), and traces (records of requests as they flow through distributed systems). Together they let operators answer different questions: metrics show what is happening at scale, logs show why a specific event occurred, and traces show how a request traversed services.
2What does the OpenTelemetry Collector primarily provide?
A.A managed cloud database for storing metrics
B.A vendor-agnostic agent that receives, processes, and exports telemetry data
C.A code instrumentation library for application developers
D.A frontend dashboard for visualizing traces
Explanation: The OpenTelemetry Collector is a vendor-agnostic proxy that can receive telemetry in many formats (OTLP, Jaeger, Zipkin, Prometheus, Fluent Forward), process it via pipelines (batching, filtering, attribute enrichment), and export it to one or more backends. It decouples application instrumentation from backend choice.
3Which protocol is the native, vendor-neutral wire format for OpenTelemetry data?
A.StatsD
B.Graphite plaintext
C.OTLP (OpenTelemetry Protocol)
D.Syslog
Explanation: OTLP (OpenTelemetry Protocol) is the native protocol for transmitting metrics, logs, and traces between SDKs, Collectors, and backends. It is defined by the OpenTelemetry project and is available over gRPC and HTTP/protobuf, with HTTP/JSON as an option for browsers and constrained environments.
4In the RED method for monitoring services, what do the letters R, E, and D stand for?
A.Reliability, Endurance, Density
B.Rate, Errors, Duration
C.Requests, Exceptions, Defects
D.Resources, Events, Dependencies
Explanation: The RED method, popularized by Tom Wilkie, focuses on three request-centric metrics for any service: Rate (requests per second), Errors (rate or count of failed requests), and Duration (latency distribution of requests). RED is well suited to request-driven, user-facing services such as HTTP and RPC APIs.
5In Brendan Gregg's USE method, what do U, S, and E represent?
A.Uptime, Speed, Errors
B.Utilization, Saturation, Errors
C.Usage, Service, Events
D.Users, Sessions, Exceptions
Explanation: USE stands for Utilization, Saturation, and Errors. It is applied to every resource (CPU, memory, disk, network) to quickly identify performance bottlenecks. Utilization is the percent time the resource was busy, saturation is the queue depth or backlog, and errors are the count of error events for the resource.
6Which Prometheus collection model does the server use by default?
A.Push: applications POST samples to Prometheus
B.Pull: Prometheus scrapes HTTP endpoints exposed by targets
C.Stream: long-lived gRPC connection per target
D.Polling DNS TXT records
Explanation: Prometheus uses a pull (scrape) model: the server periodically issues HTTP GET requests to /metrics endpoints exposed by instrumented applications and exporters. This makes target health observable, lets Prometheus rate-limit itself, and avoids needing instrumented apps to know where the server lives.
7Which Prometheus metric type represents a value that can go up or down, such as current memory usage?
A.Counter
B.Gauge
C.Histogram
D.Summary
Explanation: A Gauge is a metric that can arbitrarily go up and down. It is suitable for instantaneous measurements such as current memory in use, queue depth, or temperature. By contrast, a Counter only ever increases (or resets to zero on process restart).
8Which PromQL function calculates the per-second average rate of increase of a counter over the supplied range?
A.delta()
B.rate()
C.avg_over_time()
D.absent()
Explanation: rate(v[range]) computes the per-second average rate of increase of a counter over the time range, automatically handling counter resets. It is the canonical way to convert a counter into a rate, for example rate(http_requests_total[5m]) yields requests per second over the last 5 minutes.
9What does an SLI (Service Level Indicator) measure?
A.The legal contract between a provider and customer
B.A specific quantitative measure of an aspect of service quality, such as request success ratio
C.The internal target the team commits to internally
D.The maximum allowable downtime per quarter
Explanation: An SLI is a carefully defined quantitative measure of service quality, typically expressed as the ratio of good events to total events (for example, the proportion of requests with HTTP status < 500 served within 250 ms). SLIs are the raw input that SLOs and error budgets are derived from.
10What is an error budget?
A.The dollar amount allocated to fix bugs each quarter
B.The amount of unreliability allowed by an SLO before action must be taken
C.A list of error codes the application is allowed to return
D.The maximum number of incidents per year
Explanation: An error budget is the allowable amount of unreliability under an SLO, typically expressed as 100% minus the SLO target. For example, a 99.9% availability SLO over 30 days yields ~43.2 minutes of allowable downtime — once consumed, teams are expected to halt feature work and focus on reliability.

About the LF Observability Exam

The Linux Foundation Observability Self-Hosted Fundamentals certification validates working knowledge of OpenTelemetry, Prometheus, Grafana, Loki, Tempo, Jaeger, fluent bit/fluentd, and eBPF observability tooling. It covers the three pillars (metrics, logs, traces), RED and USE methods, four golden signals, SLI/SLO/error-budget design, and how to operate a self-hosted telemetry pipeline on Kubernetes.

Exam sponsor: Linux Foundation (PSI proctoring). The requirements and fees below concern the certification or admission exam, separate from our free practice resources.

Questions

60 questions

Time Limit

90 minutes

Passing Score

75%

Exam / Certification Fees

$250 (exam voucher)

Exam sponsor website

Reported exam pass rate: Not published. Linux Foundation does not release official pass-rate data for foundational exams Exam sponsor website

Fees, eligibility, and exam policies can change. Confirm them with the exam sponsor before applying or paying.

Our practice resources: topics covered

We aim to reflect publicly available exam outlines and topic information in our study resources. Coverage, format, and difficulty may differ from the actual exam, and we cannot guarantee that every detail is accurate or current. Confirm exam requirements, fees, and policies with the official exam sponsor.

20%

Observability Fundamentals

Three pillars (metrics, logs, traces), RED method (Rate/Errors/Duration), USE method (Utilization/Saturation/Errors), four golden signals, observability vs monitoring, and high-cardinality wide events

25%

OpenTelemetry

OTel SDK and Collector, OTLP wire protocol, semantic conventions, resource attributes, baggage, manual vs automatic instrumentation, tail vs head sampling, and Collector deployment patterns (sidecar, agent, gateway)

25%

Prometheus and PromQL

Scrape model, metric types (counter, gauge, histogram, summary), PromQL (rate, irate, increase, histogram_quantile), recording rules, alerting rules, Alertmanager (routing, grouping, silences, inhibition), exporters, federation, and long-term storage with Thanos or Mimir

20%

Logging and Tracing

Loki and LogQL, Tempo and TraceQL, Jaeger storage backends, Fluent Bit and Fluentd, structured logging, W3C Trace Context (traceparent/tracestate), span attributes/events/links, exemplars, and trace-log correlation

10%

SLO/SLI and eBPF Observability

SLI/SLO/SLA definitions, error budgets, multi-window multi-burn-rate alerts, latency SLIs, alert fatigue avoidance, and eBPF observability tools (Pixie, Parca, Cilium Hubble)

Preparing for the LF Observability Exam

What You Need to Know

  • Passing score: 75%
  • Exam length: 60 questions
  • Time limit: 90 minutes
  • Exam / certification fees: $250 (exam voucher) Official sources

Using Our Practice Resources

  • Work through all 100 available questions
  • Review every answer and explanation
  • Track weak areas and revisit them
  • Use our AI tutor for tough concepts

LF Observability: Suggested Study Strategy

1Memorize the three pillars (metrics, logs, traces) and how each one answers different operator questions before moving on
2Practice writing PromQL: rate(metric[5m]), histogram_quantile(0.95, sum by (le)(rate(bucket[5m]))), and increase() patterns until they feel natural
3Know the OpenTelemetry signal types and instruments cold: Counter vs UpDownCounter, Histogram, and Asynchronous Counter
4Remember W3C Trace Context headers — traceparent and tracestate — and how head-based vs tail-based sampling differ
5Drill the RED method (Rate, Errors, Duration), USE method (Utilization, Saturation, Errors), and the four golden signals (latency, traffic, errors, saturation)
6Compute error budgets quickly: a 99.9% SLO over 30 days = ~43.2 minutes of allowed downtime; understand multi-window multi-burn-rate alerts
7Compare Loki labels to Prometheus labels — both reward low cardinality; know why request IDs should never be Loki labels
8Stand up a small LGTM stack (Loki, Grafana, Tempo, Mimir) plus the OTel Collector locally — the muscle memory pays off on scenario questions

Frequently Asked Questions

What does the LF Observability Self-Hosted Fundamentals exam cover?

The exam covers the three pillars of observability (metrics, logs, traces), OpenTelemetry SDK and Collector, OTLP, Prometheus and PromQL, Grafana, Loki/LogQL, Tempo/TraceQL, Jaeger, Fluent Bit/Fluentd, eBPF tools (Pixie, Parca, Cilium Hubble), and SLI/SLO/error-budget design for self-hosted stacks.

What is the format and passing score?

The exam is 60 multiple-choice questions delivered online with PSI proctoring. Candidates have 90 minutes and need to score 75% to pass. Linux Foundation foundational exams typically include one free retake within 12 months of purchase.

Is this the same as the OpenTelemetry Certified Associate (OTCA) or PCA?

It is broader than either. OTCA focuses specifically on OpenTelemetry and PCA on Prometheus. The Observability Self-Hosted Fundamentals exam combines both stacks plus logs (Loki, Fluent Bit), traces (Tempo, Jaeger), eBPF observability, and SLO/SLI design.

Do I need to know Kubernetes to pass?

Familiarity with Kubernetes helps because most self-hosted observability stacks run on Kubernetes (DaemonSets for log collectors, sidecars for OTel Collectors, kube-state-metrics, cAdvisor). Deep cluster operations knowledge is not required, but you should be comfortable with pods, services, and YAML.

Which Linux Foundation courses align with this exam?

LFS148 (Getting Started with OpenTelemetry, free) and LFS241 (Monitoring Systems and Services with Prometheus, paid) cover the bulk of the material. LFS162 (DevOps and SRE) and LFS261 (SRE Foundations) help with the SLO/SLI portion. Hands-on practice with Grafana, Loki, and Tempo is strongly recommended.