The Prometheus Certified Associate (PCA) exam, offered by the Linux Foundation as part of the Cloud & Containers Certifications program, validates your ability to deploy, configure, and troubleshoot Prometheus monitoring systems in production environments. This exam is designed for DevOps engineers, site reliability engineers, and cloud platform operators who work with containerized infrastructure and need to implement observability solutions. This page provides a focused study roadmap, covers exam formats, and guides you through effective preparation strategies to build confidence before test day.
Use this topic map to guide your study for Linux Foundation PCA (Prometheus Certified Associate) within the Cloud & Containers Certifications path.
The PCA exam combines knowledge-based and scenario-driven questions to assess both conceptual understanding and practical decision-making in real-world monitoring contexts.
Questions progress in difficulty, moving from foundational concepts to complex troubleshooting and optimization tasks that reflect actual operational challenges.
An efficient study plan breaks the five core topics into weekly goals, allowing time for hands-on practice and review. Allocate roughly one week per topic, leaving a final week for integrated review and mock exams. This pacing ensures you build depth in each area while maintaining connections between concepts.
Explore other Linux Foundation certifications: view all Linux Foundation exams.
Strengthen your preparation with up-to-date resources from validexamdumps.com. These materials align to PCA and cover practical scenarios with clear explanations.
Visit the exam page to download the PDF, Online Practice Test, or get a bundle discount for both formats: Prometheus Certified Associate.
Prometheus Fundamentals and PromQL typically account for a significant portion of the exam, as they form the foundation for all other topics. Alerting & Dashboarding and Instrumentation and Exporters are equally important for practical application. Observability Concepts provides essential context but is tested more lightly; focus on understanding how it connects to the other domains.
Observability Concepts define what you need to measure. Prometheus Fundamentals and Instrumentation and Exporters handle data collection. PromQL lets you query and analyze that data. Alerting & Dashboarding turns insights into actionable information for teams. Understanding these connections helps you design end-to-end monitoring solutions rather than treating topics in isolation.
Practical experience with Prometheus deployment, metric instrumentation, and query writing is highly valuable. Prioritize labs that involve setting up a Prometheus instance, scraping metrics from a sample application, writing PromQL queries, and configuring basic alerts. Even a few weeks of hands-on work with these tasks significantly improves exam readiness and real-world confidence.
Misunderstanding PromQL operators and aggregation behavior is frequent; practice queries until you can predict output without running them. Confusing metric types (counter, gauge, histogram) and their use cases is another common gap. Overlooking cardinality issues and retention policy implications in scenario questions also leads to incorrect answers. Review these areas thoroughly during final review.
Spend the first three days reviewing weak topics and re-reading explanations from practice tests. Dedicate day four to a full-length timed mock exam under realistic conditions. Days five and six focus on spot-checking specific PromQL patterns and alert rule syntax. On exam day, arrive early, review exam instructions, and pace yourself to leave time for review before submission.
Which metric type uses the delta() function?
The delta() function in PromQL calculates the difference between the first and last samples in a range vector over a specified time window. This function is primarily used with gauge metrics, as they can move both up and down, and delta() captures that net change directly.
For example, if a gauge metric like node_memory_Active_bytes changes from 1000 to 1200 within a 5-minute window, delta(node_memory_Active_bytes[5m]) returns 200.
Unlike rate() or increase(), which are designed for monotonically increasing counters, delta() is ideal for metrics representing resource levels, capacities, or instantaneous measurements that fluctuate over time.
Verified from Prometheus documentation -- PromQL Range Functions -- delta(), Gauge Semantics and Usage, and Comparing delta() and rate() sections.
If the vector selector foo[5m] contains 1 1 NaN, what would max_over_time(foo[5m]) return?
In PromQL, range vector functions like max_over_time() compute an aggregate value (in this case, the maximum) over all samples within a specified time range. The function ignores NaN (Not-a-Number) values when computing the result.
Given the range vector foo[5m] containing samples [1, 1, NaN], the maximum value among the valid numeric samples is 1. Therefore, max_over_time(foo[5m]) returns 1.
Prometheus functions handle missing or invalid data points gracefully---ignoring NaN ensures stable calculations even when intermittent collection issues or resets occur. The function only errors if the selector is syntactically invalid or if no numeric samples exist at all.
Verified from Prometheus documentation -- PromQL Range Vector Functions, Aggregation Over Time Functions, and Handling NaN Values in PromQL sections.
With the following metrics over the last 5 minutes:
up{instance="localhost"} 1 1 1 1 1
up{instance="server1"} 1 0 0 0 0
What does the following query return:
min_over_time(up[5m])
The min_over_time() function in PromQL returns the minimum sample value observed within the specified time range for each time series.
In the given data:
For up{instance='localhost'}, all samples are 1. The minimum value over 5 minutes is therefore 1.
For up{instance='server1'}, the sequence is 1 0 0 0 0. The minimum observed value is 0.
Thus, the query min_over_time(up[5m]) returns two series --- one per instance:
{instance='localhost'} 1
{instance='server1'} 0
This query is commonly used to check uptime consistency. If the minimum value over the time window is 0, it indicates at least one scrape failure (target down).
Verified from Prometheus documentation -- PromQL Range Vector Functions, min_over_time() definition, and up Metric Semantics sections.
Which PromQL expression computes how many requests in total are currently in-flight for the following time series data?
apiserver_current_inflight_requests{instance="1"} 5
apiserver_current_inflight_requests{instance="2"} 7
In Prometheus, when you have multiple time series that represent the same type of measurement across different instances, the sum() aggregation operator is used to compute their total value.
Here, each instance (1 and 2) exposes the metric apiserver_current_inflight_requests, indicating the number of active API requests currently being processed.
To find the total number of in-flight requests across all instances, the correct expression is:
sum(apiserver_current_inflight_requests)
This returns 5 + 7 = 12.
min() would return the lowest value (5).
max() would return the highest value (7).
sum_over_time() calculates the cumulative sum over a range vector, not the current value, so it's incorrect here.
Verified from Prometheus documentation -- Aggregation Operators and Summing Across Dimensions sections.
What is the role of the Pushgateway in Prometheus?
The Pushgateway is a Prometheus component used to handle short-lived batch jobs that cannot be scraped directly. These jobs push their metrics to the Pushgateway, which then exposes them for Prometheus to scrape.
This ensures metrics persist beyond the job's lifetime. However, it's not designed for continuously running services, as metrics in the Pushgateway remain static until replaced.
