Automation in DevOps practices is central to platform engineering because it enables faster, reliable, and repeatable deployments . Option D is correct: automation accelerates deployments, reduces bottlenecks, and enables continuous delivery and rapid iterations. By automating build, test, and deployment pipelines, teams can deliver new features quickly while maintaining high quality and compliance.

Option A is incorrect because automation does not reduce the need for communication—it complements collaboration by removing friction. Option B is unrealistic: some manual oversight may remain (e.g., in production approvals for sensitive workloads). Option C is not a primary benefit—while tools may be involved, the focus is on outcomes, not tool dependency.

By embedding automation, teams reduce toil, enforce consistency, and free developers to focus on value creation rather than repetitive tasks. This results in shorter lead times, higher deployment frequency, and overall improved developer experience, which aligns with DORA metrics.

One of the primary objectives of internal developer platforms (IDPs) is to improve developer experience by reducing cognitive load. Complex Kubernetes configurations often overwhelm developers who simply want to consume services and deploy code without worrying about infrastructure intricacies.

Option B is correct because implementing a self-service web portal (or developer portal) abstracts away Kubernetes complexities, providing developers with easy access to platform services through standardized workflows, templates, and golden paths. This aligns with platform engineering principles: empowering developers with self-service capabilities while maintaining governance, security, and compliance.

Option A increases burden unnecessarily and negatively impacts productivity. Option C limits access to services, reducing flexibility and developer autonomy, which goes against the core goal of IDPs. Option D, while helpful for education, does not remove complexity—it only shifts the responsibility back to the developer. By leveraging portals, APIs, and automation, platform teams allow developers to focus on building business value instead of managing infrastructure details.

Platform engineering clearly separates responsibilities between platform teams and application teams. Option C is correct because platform teams manage the platform and infrastructure layer , ensuring stability, compliance, and availability, while application teams own their applications , including troubleshooting application-specific issues.

Option A (creating a single merged team) introduces inefficiency and removes specialization. Option B incorrectly suggests application teams should also solve infrastructure issues, which conflicts with platform-as-a-product principles. Option D places all responsibilities on platform teams, which creates bottlenecks and undermines application team ownership.

By splitting responsibilities, IDPs empower developers with self-service provisioning while maintaining clear boundaries. This ensures both agility and accountability: platform teams focus on enabling and securing the platform, while application teams take ownership of their code and services.

The most effective approach for scalable Kubernetes infrastructure provisioning is Crossplane compositions . Option D is correct because compositions let platform teams define custom CRDs (Composite Resources) that abstract infrastructure details while embedding organizational policies and guardrails. Developers then consume these abstractions through simple Kubernetes-native APIs, enabling self-service at scale.

Option A (Helm with values.yaml) is useful for application deployment but not for scalable infrastructure provisioning across multiple clouds. Option B (imperative scripts) lacks scalability, repeatability, and governance. Option C (static YAML with kubectl apply) is manual and not suited for dynamic, multi-team environments.

Crossplane compositions allow platform teams to curate golden paths while giving developers autonomy. This reduces complexity, ensures compliance, and supports multi-cloud provisioning—all key aspects of platform engineering.

The most effective stage to generate a Software Bill of Materials (SBOM) is during the build process . Option C is correct because the build phase is when dependencies are resolved and artifacts (e.g., container images, binaries) are created. Generating an SBOM at this point provides a complete, accurate inventory of all included libraries and components, which is critical for vulnerability scanning, license compliance, and supply chain security.

Option A (testing) is too late to capture all dependencies reliably. Option B (before committing code) cannot provide a full SBOM because builds often introduce additional dependencies. Option D (after deployment) delays insights until production, missing the opportunity to detect and remediate issues early.

Integrating SBOM generation into CI/CD pipelines enables shift-left security, ensuring vulnerabilities are detected early and allowing remediation before artifacts reach production. This aligns with CNCF supply chain security practices and platform engineering goals.

Abstract APIs are an essential component of platform engineering, providing a simplified interface for developers to consume infrastructure and cloud services without deep knowledge of provider-specific details. Option B is correct because abstractions allow platform teams to curate services with built-in guardrails , ensuring compliance, security, and operational standards are enforced automatically. Developers get the benefit of self-service and flexibility while the platform team ensures governance.

Option A would slow down the process, defeating the purpose of abstraction. Option C removes guardrails, which risks security and compliance violations. Option D allows uncontrolled deployments, which can create chaos and undermine platform governance.

Abstract APIs strike the balance between developer experience and organizational control. They provide golden paths and opinionated defaults while maintaining the flexibility needed for developer productivity. This approach ensures efficient service provisioning at scale with reduced cognitive load on developers.

OpenTelemetry is an open-source CNCF project that provides vendor-neutral, standardized APIs, SDKs, and agents for collecting and exporting observability data such as metrics, logs, and traces. Option C is correct because OpenTelemetry’s purpose is to unify how telemetry data is generated, transmitted, and consumed, regardless of which backend (e.g., Prometheus, Jaeger, Elastic, commercial APM tools) is used.

Option A is incorrect because OpenTelemetry supports all three signal types (metrics, logs, traces), not just logs. Option B is incorrect because it is an open, community-driven standard and not tied to a single vendor or cloud provider. Option D is misleading because OpenTelemetry covers distributed applications, services, and infrastructure—far beyond just infrastructure monitoring.

OpenTelemetry reduces vendor lock-in and promotes interoperability, making it a cornerstone of cloud native observability strategies. Platform engineering teams rely on it to ensure consistent data collection, enabling better insights, faster debugging, and improved reliability of cloud native platforms.