PCA course and practice exam: Prometheus Certified Associate
This PCA course has 35 video lessons and 84 graded labs, and its PCA 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.
Observability concepts, PromQL, instrumentation and alerting
Prepares you for PCA: observability concepts, Prometheus fundamentals, PromQL, instrumentation and exporters, and alerting and dashboards.
Intermediate · 3 hours · 35 lessons · 89 labs
PCA exam guide
The PCA exam (Prometheus Certified Associate, by CNCF / The Linux Foundation): 90 minutes; pass mark: 75%; cost: USD 250 (includes one retake and 12 months to schedule); bundles USD 299 with LFS241, USD 495 with THRIVE-ONE.
- Format: Online, proctored, multiple-choice
- Duration: 90 minutes
- Questions: Not published
- Pass mark: 75%
- Cost: USD 250 (includes one retake and 12 months to schedule); bundles USD 299 with LFS241, USD 495 with THRIVE-ONE
- Valid for: 2 years
- Delivery: Online, proctored (PSI)
- Prerequisites: None
Exam domains and weights
- Observability Concepts: 18%
- Prometheus Fundamentals: 20%
- PromQL: 28%
- Instrumentation and Exporters: 16%
- Alerting & Dashboarding: 18%
A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
10 PCA sample questions with answers: free to read, no account needed.
Common questions
How long is the PCA exam?
The PCA exam lasts 90 minutes.
What is the PCA passing score?
The pass mark is 75%.
How much does the PCA exam cost?
USD 250 (includes one retake and 12 months to schedule); bundles USD 299 with LFS241, USD 495 with THRIVE-ONE.
Is there a free PCA practice test?
Yes. A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
Source: PCA exam page (Linux Foundation Education) (CNCF / The Linux Foundation), checked 2026-10-03.
Who it is for
Intermediate level.
For SREs, operations staff and developers preparing for the Prometheus Certified Associate exam, who monitor services with Prometheus, PromQL and alerts.
What you don't need yet:
- No previous Prometheus experience
- No Prometheus server to set up: labs open in your browser
- No Python or other programming language: labs use PromQL and YAML
What helps:
- A rough idea of web services: requests, errors and servers
No formal prerequisites. The courses under "Take first" cover what helps.
Take first:
Take next:
- OpenTelemetry Certified Associate (OTCA) Exam Prep — Intermediate
- Full-Stack Observability: Metrics, Tracing & Logging — Advanced
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
PCA is an online, proctored, multiple-choice exam: passing shows you know Prometheus, PromQL and alerting. It doesn't test hands-on skill or replace monitoring production systems; our graded labs have you write PromQL and YAML in the browser.
Exam objectives this course teaches
Prometheus Certified Associate (PCA)
- Observability Concepts (18% of the exam): Metrics; Understand logs and events; Tracing and Spans; Push vs Pull; Service Discovery; Basics of SLOs, SLAs, and SLIs
- Prometheus Fundamentals (20% of the exam): System Architecture; Configuration and Scraping; Understanding Prometheus Limitations; Data Model and Labels; Exposition Format
- PromQL (28% of the exam): Selecting Data; Rates and Derivatives; Aggregating over time; Aggregating over dimensions; Binary operators; Histograms; Timestamp Metrics
- Instrumentation and Exporters (16% of the exam): Client Libraries; Instrumentation; Exporters; Structuring and naming metrics
- Alerting & Dashboarding (18% of the exam): Dashboarding basics; Configuring Alerting rules; Understand and Use Alertmanager; Alerting basics (when, what, and why)
Labs
89 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
- Six Minutes Nobody Saw: Prometheus In One Outage (3 labs): You can explain how Prometheus scrapes and stores metrics, run PromQL queries for up and an error ratio, and describe the PCA exam and its five domains.
- Ninety Minutes, No Question Count: Exam Strategy (2 labs): You can plan PCA pacing from the published facts, run three passes through the paper and cross out wrong options with four checks.
Observability Concepts
- 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.
- Prometheus Scraping And The Pull Model (2 labs): You can describe what a scrape is, configure a target, read the health of every target, and explain what the pull model gives you that pushing does not.
- Forty Seconds At Two: Push, Pull And Service Discovery (2 labs): You can decide when the Pushgateway is the right tool, explain what the client pushes, and predict which discovered targets relabelling keeps.
- Ninety Nine Percent Of What? SLIs, SLOs And SLAs (3 labs): You can tell SLIs, SLOs and SLAs apart, compute an error budget, measure an availability SLI from counters and judge an outage by its burn rate.
- Observability Sprint: One Failed Checkout (3 labs): You can match questions to logs, traces and metrics, choose between pull and the Pushgateway, and do error budget and burn rate arithmetic, under exam conditions.
Prometheus Fundamentals
- Where Did Two Hours Go? Prometheus Architecture (3 labs): You can name the components of a Prometheus system and their roles, follow a sample from scrape to block, and explain the write-ahead log, blocks, retention, remote write and high availability.
- A Week Without A Scrape: Configuration And Relabelling (3 labs): You can read a scrape configuration, predict which targets relabelling keeps and what labels they carry, and validate a config with promtool before a reload.
- Cart Versus cart: The Data Model And What A Scrape Returns (2 labs): You can identify a time series by its name and labels, read a scraped page in the Prometheus text and OpenMetrics formats, and say which labels Prometheus adds.
- The Prometheus Exposition Format (2 labs): You can read and write the text format a scrape returns, including help and type lines, label syntax, histogram buckets, and the rules that make a page valid.
- Cardinality And How It Bankrupts You (1 lab): You can count the series a metric will create before you ship it, recognise the labels that must never exist, and say where high cardinality data belongs instead.
- Off By Five: What Prometheus Is Not For (3 labs): You can explain Prometheus's limitations: why it is not for exact counts or individual events, how label cardinality multiplies series, and how storage limits are handled.
- Fundamentals Sprint: Nine Calls On The Server (3 labs): You can predict whether a configuration loads, how many series a page creates and which targets relabelling keeps, under exam conditions.
PromQL
- The Server That Would Not Die: Selecting Data (3 labs): You can write instant and range vector selectors with all four matchers, shift them with offset and @, and explain the lookback window and stale markers.
- Four Thousand Requests Vanished: Rates And Derivatives (3 labs): You can compute rate, irate and increase across counter resets, choose a window, aggregate rates in the right order, and use deriv and predict_linear on gauges.
- Fifteen Requests Nobody Saw: Aggregating Over Time (3 labs): You can summarise a series over a window with the over_time functions, measure availability from up, and use subqueries and absent correctly.
- Fifteen Lines And No Answer: Aggregating Over Labels (3 labs): You can aggregate across series with by and without, rank with topk and bottomk, count targets and distinct values, and avoid the count_values trap.
- Is The New Version Worse? Binary Operators And Matching (3 labs): You can combine vectors with arithmetic, comparison and set operators, use bool, and control vector matching with on, ignoring, group_left and group_right.
- Calculating Percentiles With histogram_quantile (2 labs): You can read cumulative histogram buckets and use histogram quantile to estimate a percentile without pretending that an average describes the tail.
- Under A Second, On Average: Histograms (3 labs): You can read histogram buckets, compute quantiles with histogram_quantile, averages from _sum and _count and threshold shares from one bucket, and choose between histograms and summaries.
- The Export That Failed Quietly: Timestamp Metrics (3 labs): You can compute ages from timestamp metrics with time(), alert on them without the zero trap, and use timestamp(), a last-seen subquery and the date functions.
- PromQL Sprint: Ten Queries At Minute Twenty Two (3 labs): You can predict what PromQL queries return under exam conditions, check types and surviving labels, and tell loud parse errors from silent empty results.
Instrumentation And Exporters
- Thirty Second Checkouts Nobody Saw: Client Libraries (2 labs): You can choose the right metric type for a measurement, instrument code with the official Python client library, read what it exposes, and initialise labelled series.
- A Database You Cannot Recompile: Exporters (3 labs): You can choose between node, blackbox and textfile exporting, wire blackbox exporter with relabelling, and read real exporter output.
- Milliseconds Versus Seconds: Naming Metrics And Labels (2 labs): You can name metrics and labels to the Prometheus conventions, lint an exposition page with promtool check metrics, and spot label problems the linter cannot see.
- Instrumentation Sprint: Sixteen Calls On Code And Exporters (4 labs): You can name the series each metric type exposes, classify exporter metrics as counters or gauges, and spot naming and unit problems the way promtool does, under exam conditions.
Alerting And Dashboarding
- Paged Three Minutes Late: Alerting Rules (3 labs): You can write recording and alerting rules with for, labels and templated annotations, check them with promtool, and explain the pending and firing states and where alert delay comes from.
- Forty One Buzzes: Routing Alerts With Alertmanager (2 labs): You can read and write an Alertmanager routing tree, predict and test receivers with amtool, and choose between grouping, inhibition and silences.
- Alerting On Symptoms Versus Causes: You can choose alerts that represent customer impact and use causes as investigation evidence.
- Dashboards That Answer Questions (1 lab): You can design a focused dashboard around a user facing question, choose panels that support it, and remove decoration that cannot guide a decision.
- Twelve Green Panels: Dashboarding Basics (3 labs): You can design a Grafana dashboard around rate, errors and duration, use variables, avoid misleading panels, and speed dashboards up with recording rules.
- Alerting Sprint: Eleven Calls In Three Rounds (3 labs): You can predict alert states over time, route alerts through an Alertmanager tree, and spot rule-file mistakes, under exam conditions.
Mock And Review
- Seventy Seven Percent, Book Now? The Full Mock (2 labs): You can sit a full PCA mock under exam conditions, read the result by domain, objective and time, judge whether a mock score is safely above the pass mark, and sort every miss by its cause.
- One Week, Three Objectives: Final Review (3 labs): You can turn a mock's weakest objectives into short exam-style rounds, avoid the histogram, routing and configuration traps the PCA exam favours, and plan exam day, a retake and renewal.