PCA Study Strategy¶

Study Approach¶

Phase 1: Foundations (Week 1-2)¶

1. Observability Concepts
2. Three pillars of observability (metrics, logs, traces)
3. Monitoring vs observability distinction
4. Golden signals, RED method, USE method
5. SLIs, SLOs, and SLAs

6. Push vs pull monitoring models

7. Prometheus Architecture

8. Core components (server, TSDB, service discovery, rule engine)
9. Configuration structure (global, scrape_configs, rules, alerting)
10. Data model (metric name, labels, time series)
11. Service discovery mechanisms (Kubernetes, file, DNS, static)

12. Storage model (local TSDB, retention, WAL)

13. Metric Types

14. Counter: cumulative, only increases, use rate() for meaningful data
15. Gauge: current value, goes up and down
16. Histogram: bucketed distribution, aggregatable
17. Summary: pre-calculated quantiles, not aggregatable

Phase 2: PromQL Deep Dive (Weeks 2-3)¶

1. Query Fundamentals
2. Selectors and matchers (=, !=, =~, !~)
3. Instant vectors vs range vectors
4. Scalar and string types

5. Time durations and offsets

6. Functions and Aggregations

7. rate(), irate(), increase() for counters
8. sum, avg, min, max, count aggregations
9. by() and without() clauses for grouping
10. topk(), bottomk() for ranking
11. histogram_quantile() for percentiles
12. absent() for missing metrics detection

13. predict_linear() for forecasting

14. Advanced PromQL

15. Binary operators and vector matching
16. on() and ignoring() for label matching
17. group_left and group_right for many-to-one matching
18. Recording rules for query optimization

19. Subqueries for nested range operations

20. Practice Queries

21. Calculate request rate by endpoint
22. Compute error rate percentages
23. Calculate 95^th percentile latency from histograms
24. Identify top resource consumers
25. Create alerting expressions

Phase 3: Instrumentation, Alerting, and Exam Prep (Weeks 3-4)¶

1. Instrumentation
2. Client libraries and metric exposition
3. Naming conventions and label best practices
4. Common exporters (Node, Blackbox, kube-state-metrics)
5. Pushgateway use cases and limitations

6. Custom metric instrumentation patterns

7. Alerting

8. Alerting rules in Prometheus
9. Alertmanager routing tree
10. Grouping, inhibition, and silencing
11. Notification receivers (Slack, email, PagerDuty)

12. Alert severity levels

13. Dashboarding

14. Grafana and Prometheus integration
15. Dashboard design best practices
16. Variables and templating

17. Panel types for different data

18. Practice Exams

19. Take practice tests and review weak areas
20. Focus heavily on PromQL questions (28% of exam)
21. Review all metric type differences

Study Resources¶

Primary Resources¶

• Prometheus Documentation - Complete official docs
• PromQL Reference - Query language docs
• PCA Exam Curriculum - Official exam objectives
• Prometheus: Up and Running (O'Reilly) - Comprehensive reference book

Supplementary Resources¶

• Alertmanager Documentation - Alerting pipeline
• Grafana Documentation - Dashboard creation
• PromLens - PromQL query builder and explainer
• Prometheus Best Practices - Naming and instrumentation

Community and Forums¶

• CNCF Slack #prometheus - Prometheus channel
• r/PrometheusMonitoring - Reddit community
• Prometheus GitHub Discussions - Community Q&A

Video Courses¶

1. KodeKloud PCA - Comprehensive with labs
2. Udemy PCA Courses - Multiple options with practice exams
3. Prometheus LFD259 - Linux Foundation training
4. TechWorld with Nana - Prometheus tutorial on YouTube

Exam Tactics¶

Time Management (90 minutes, 60 questions)¶

• Average 1.5 minutes per question
• PromQL questions may take longer - budget extra time
• Answer confident questions first
• Flag uncertain questions for review
• Reserve 10-15 minutes for flagged questions

Question Strategy¶

1. Read PromQL carefully - brackets, parentheses, and function order matter
2. Check units - seconds vs milliseconds, bytes vs kilobytes
3. Counter vs gauge - using rate() on a gauge is wrong, not using rate() on a counter gives meaningless raw data
4. Histogram vs summary - know when aggregation matters
5. Eliminate wrong answers - incorrect PromQL syntax eliminates options quickly

Domain Prioritization¶

• PromQL (28%) - Largest domain, requires the most practice
• Prometheus Fundamentals (20%) - Architecture, config, data model
• Observability Concepts (18%) - Theory and methodology
• Instrumentation and Exporters (16%) - Metric types, exporters
• Alerting (10%) - Alertmanager, routing, grouping
• Dashboarding (8%) - Grafana basics

Common Pitfalls¶

Study Mistakes¶

• Not practicing PromQL - Reading about queries is not the same as writing them. Set up a local Prometheus and practice
• Ignoring observability theory - 18% of the exam covers concepts, not just Prometheus specifics
• Skipping alerting - Alertmanager concepts are testable and often misunderstood
• Not understanding metric types - The distinction between counter, gauge, histogram, and summary is fundamental

Content Mistakes¶

• Using rate() on a gauge (rate is for counters only)
• Confusing rate() with irate() (rate is smoothed, irate uses last two points)
• Thinking summaries can be aggregated across instances (they cannot)
• Not understanding that counters reset on restart (rate() handles this)
• Mixing up scrape_interval with evaluation_interval
• Not knowing that absent() returns 1 when the metric is missing (useful for alerting)

Progress Tracking¶

Self-Assessment Questions¶

Phase 1: - Can I explain the three pillars of observability? - Can I describe all Prometheus components and their roles? - Do I know all four metric types and when to use each? - Can I explain the Prometheus data model (metric name + labels)?

Phase 2: - Can I write rate(), increase(), and histogram_quantile() queries? - Do I understand the difference between instant and range vectors? - Can I use aggregation operators with by() and without()? - Can I create recording rules?

Phase 3: - Do I know common exporters and their purposes? - Can I explain Alertmanager routing, grouping, and inhibition? - Can I design a basic Grafana dashboard with Prometheus? - Am I scoring 80%+ on practice exams?

Readiness Indicators¶

You are ready for the exam when: - [ ] You can write PromQL queries for common monitoring scenarios - [ ] You understand all four metric types and their trade-offs - [ ] You can explain the Prometheus architecture end to end - [ ] You understand Alertmanager routing and notification flow - [ ] You score 80%+ consistently on practice exams