> ## Documentation Index > Fetch the complete documentation index at: https://notes.kodekloud.com/llms.txt > Use this file to discover all available pages before exploring further. # Course Conclusion > Concise recap and exam study checklist for aspiring Certified Cloud Native Platform Engineers covering platform architecture, GitOps delivery, platform APIs, observability, operations, security, and practical lab preparation This course mapped the core knowledge and hands-on skills you need to become a confident platform engineer and to prepare for the Certified Cloud Native Platform Engineer (CNPE) exam. Below is a concise recap of each domain, how they interconnect, and a practical checklist to help you prioritize study and lab time. Section 1 — Platform architecture and infrastructure (15% of the exam) * Resource governance: Use `ResourceQuota` for namespace-level quotas and `LimitRange` for per-pod/container defaults and limits — these controls complement each other to enforce resource discipline and predictable cluster behavior. * Persistent storage: Understand `PersistentVolumeClaims` (PVCs), `StorageClass` parameters, and reclaim policies for lifecycle and cost control. * Platform networking: From Cluster Services through the Gateway API, learn how traffic flows across the platform and how ingress/east-west connectivity is managed. * Cost optimization: Use tools like OpenCost to identify idle resources, right-size workloads, and reduce platform spend. The image outlines four components of "Platform Architecture and Infrastructure," including Resource Governance, Persistent Storage, Platform Networking, and Cost Optimization, each with a brief description and an icon. Although this domain represents 15% of the exam, it underpins everything else — storage, networking, governance, and cost controls are foundational to reliable platforms. Section 2 — Delivery and GitOps (25%) * GitOps principles: Desired-state configuration, drift detection, and repository design patterns for collaboration and auditability. * Argo CD deep dive: Applications, sync policies, self-heal, pruning, and Helm integration for reproducible deployments. * CI/CD with Tekton: Tasks, Pipelines, Workspaces, and how to structure pipelines for repeatable, testable delivery. * Progressive delivery: Argo Rollouts (or similar) combined with Istio or other service meshes to implement canaries and traffic-splitting strategies. * Troubleshooting delivery failures: Common failure modes, rollback strategies, and recovery patterns for production incidents. Section 3 — Platform APIs and self-service (25%) * APIs as products: Design developer-friendly contracts and clear service level expectations for platform-managed resources. * CRDs: Validation schemas, short names, versioning, and upgrade strategies to minimize breaking changes. * Operators and reconciliation: How reconciler loops, backoffs, and idempotency enable reliable automation (cert-manager is a concrete example that manages TLS lifecycle). * Workflow orchestration: Argo Workflows — DAGs, parameters, artifacts, templates — for complex CI/CD and data pipelines. * Crossplane compositions: Translate developer-facing custom resources into cloud infrastructure and managed services. The image outlines topics in "Section 3: Platform APIs and Self-Service," covering APIs as products, CRDs, operators, workflows, and crossplane, each with a brief description and icon. Section 4 — Observability and operations (20%) * Metrics and dashboards: Prometheus for collection and Grafana for visualizing service health and SLOs. * Alerts: Alertmanager for routing, grouping, and delivering alerts to the right team/channel. * Tracing: OpenTelemetry and Jaeger for distributed tracing to diagnose latency and service interaction issues. * Incident response: Triage, remediation, validation, and post-incident review practices supported by runbooks and automated checks. The image outlines Section 4: Observability and Operations, detailing components like Prometheus, Grafana, AlertManager, Tracing, and Troubleshooting, with respective functions. Section 5 — Security and policy (the remaining domain) * RBAC: Fine-grained role-based access control to limit privileges and scope of changes. * Admission control: Gatekeeper (Rego) for complex policy enforcement; Kyverno for YAML-native validation, mutation, and generation. * Pod hardening: Pod Security Standards (PSS) to enforce runtime constraints and reduce attack surface. * Service identity and encryption: Istio mTLS (or equivalent service mesh tooling) for secure service-to-service encryption and identity. * Supply chain security: Image scanning, signing, and provenance; cluster policies that block unsigned or vulnerable images. The big picture — how the domains connect * These five domains work together as a continuous loop: 1. Platform APIs: Developers request infrastructure or services via custom resources (self-service). 2. GitOps delivery: Argo CD (or similar) reconciles desired state and deploys changes; progressive delivery patterns may be used for safe rollouts. 3. Observability: Prometheus, Grafana, and tracing tools validate behavior, capture metrics, and expose issues. 4. Security and policy: Admission controllers, PSS, and mTLS enforce guardrails and secure communication. * All of this runs on top of platform architecture: governance, storage, networking, and cost controls. The image illustrates a four-step process connecting platform architecture and infrastructure: defining APIs, GitOps delivery, observability, and enforcing security and policy. Each step is represented by a colored gear icon, highlighting the sequence and roles. Exam breakdown and study focus | Domain | Exam weight | Key study focus and tools | | -------------------------------------- | ----------: | --------------------------------------------------------------------------------- | | Platform architecture & infrastructure | 15% | `ResourceQuota`, `LimitRange`, PVCs/StorageClass, Gateway API, OpenCost | | Delivery & GitOps | 25% | GitOps principles, Argo CD, Tekton pipelines, Argo Rollouts, progressive delivery | | Platform APIs & self-service | 25% | CRDs, operators, `cert-manager`, Argo Workflows, Crossplane compositions | | Observability & operations | 20% | Prometheus, Grafana, Alertmanager, OpenTelemetry/Jaeger, incident playbooks | | Security & policy | 15% | RBAC, Gatekeeper (Rego), Kyverno, PSS, mTLS, image signing/scanning | Practical exam preparation checklist 1. Finish every hands-on lab in the course; labs reflect real exam tasks. 2. Re-run labs to improve speed and confidence—time yourself on typical tasks. 3. Take mock exams to pinpoint weak topics and prioritize targeted practice. 4. Review exam environment tips: navigation, time management, and common pitfalls. 5. When practice is consistent and mock scores are stable, schedule your exam. Finish every lab, practice repeatedly to build speed, and use mock exams to target weak spots — those three steps will pay off the most on exam day. Links and references * [Kubernetes Concepts](https://kubernetes.io/docs/concepts/) * [Argo CD](https://argo-cd.readthedocs.io/) * [Tekton Pipelines](https://tekton.dev/) * [Argo Workflows](https://argoproj.github.io/argo-workflows/) * [Prometheus](https://prometheus.io/) and [Grafana](https://grafana.com/) * [OpenTelemetry](https://opentelemetry.io/) and [Jaeger](https://www.jaegertracing.io/) * [Gatekeeper (OPA)](https://open-policy-agent.github.io/gatekeeper/) and [Kyverno](https://kyverno.io/) * [Crossplane](https://crossplane.io/) and [cert-manager](https://cert-manager.io/) * [OpenCost](https://opencost.io/) You’ve completed the course, practiced with real tools, and learned how the pieces fit together. Trust your preparation, manage your time during the exam, and go earn your CNPE — you’re ready. Thank you for taking this course — I’m confident you’ll do great.