OpenCost is the CNCF-supported open-source project designed specifically for Kubernetes cost visibility and optimization. Option B is correct because OpenCost provides granular, real-time allocation of Kubernetes costs across namespaces, workloads, and teams. This allows organizations to understand true cost drivers and optimize resource utilization effectively.
Option A (APM tools) may track performance but usually lack deep integration with Kubernetes cost allocation. Option C provides partial visibility but requires complex manual correlation of resource usage with billing data. Option D (cloud provider estimators) typically offer limited or high-level insights and do not map costs down to Kubernetes workloads.
By adopting OpenCost, platform teams can align financial accountability with engineering usage, a practice known as FinOps. This supports sustainable scaling, cost efficiency, and transparency-critical aspects of measuring platform success.
References:- CNCF OpenCost Project- CNCF Platforms Whitepaper- Cloud Native Platform Engineering Study Guide

Proper documentation is critical for fostering collaboration through APIs. Option A is correct because well- documented APIs ensure that all teams-platform engineers, developers, and operations-understand how to consume and integrate services effectively. Clear documentation reduces friction, accelerates adoption, and minimizes support overhead.
Option B (no versioning) is poor practice, as versioning ensures backward compatibility and safe upgrades.
Option C (tight coupling) restricts collaboration and creates silos, which goes against platform engineering principles. Option D (complex design) reduces usability and increases cognitive load, the opposite of platform goals.
APIs serve as the contracts between teams and systems. In platform engineering, well-documented, versioned, and abstracted APIs provide a consistent and predictable way to interact with platform services, improving collaboration and developer experience.
References:- CNCF Platforms Whitepaper- Team Topologies Guidance- Cloud Native Platform Engineering Study Guide

Crossplane integrates tightly with GitOps workflows by extending Kubernetes with infrastructure APIs.
Option B is correct because infrastructure resources (databases, networks, S3 buckets, etc.) are defined declaratively in Git repositories. Git becomes the single source of truth, while Crossplane controllers automatically reconcile the desired state into real infrastructure across supported cloud providers.
Option A reflects imperative scripting, which contradicts GitOps principles. Option C (manual provisioning) lacks automation, governance, and repeatability. Option D involves manual application with kubectl, which bypasses GitOps reconciliation loops.
With Crossplane and GitOps, teams achieve consistent, reproducible, and auditable infrastructure provisioning at scale. This enables full alignment with cloud native platform engineering principles of declarative management, self-service, and extensibility.
References:- CNCF Crossplane Documentation- CNCF GitOps Principles- Cloud Native Platform Engineering Study Guide

Resource allocation varies between environments to balance cost, performance, and reliability. Option D is correct because development environments usually require fewer resources and are optimized for speed and cost efficiency, while production environments require stricter limits to ensure stability, scalability, and resilience under real user traffic.
Option A (identical settings) may simplify management but wastes resources and fails to account for different needs. Option B (maximizing usage in all environments) increases costs unnecessarily. Option C (strict parity) may be used in testing scenarios but is impractical as a universal rule.
By tailoring resource limits per environment, platforms ensure cost efficiency in dev/staging and robust performance in production. This practice is central to cloud native engineering, as it allows teams to innovate quickly while maintaining governance and operational excellence in production.
References:- CNCF Platforms Whitepaper- Kubernetes Resource Management Guidance- Cloud Native Platform Engineering Study Guide

Metrics are the observability signal most effective at detecting real-time performance bottlenecks in Kubernetes. Option C is correct because metrics provide numerical, time-series data (e.g., CPU usage, memory consumption, request latency, pod restarts) that can be aggregated and monitored continuously. This makes them the best fit for identifying performance degradation and bottlenecks before they escalate into outages.
Option A (logs) capture detailed events but are better for debugging after issues occur. Option B (traces) provide request-level insights across distributed systems but focus on transaction flow rather than cluster-wide performance. Option D (events) record discrete system changes but are not designed for continuous performance monitoring.
Metrics integrate with tools like Prometheus and Grafana, enabling SLO/SLI monitoring and alerting. They allow proactive capacity planning, scaling decisions, and real-time issue detection-critical aspects of cloud native observability.
References:- CNCF Observability Whitepaper- Prometheus CNCF Documentation- Cloud Native Platform Engineering Study Guide