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.

Extensibility in cloud native platform engineering depends on modular design with well-defined APIs and interfaces. Option A is correct because modular, API-driven architecture allows new capabilities (e.g., observability, self-service provisioning, policy engines) to be added, updated, or replaced independently, without disrupting the entire system. This enables innovation, adaptability, and continuous improvement.

Option B emphasizes governance, but relying solely on specialist approvals slows agility and reduces scalability. Option C (monolithic architecture) restricts flexibility and increases cognitive load for developers. Option D (centralized configuration) provides consistency but risks bottlenecks and does not inherently enable extensibility.

Modularity and APIs are fundamental to platform engineering because they support composability, golden paths, and integration of open-source/cloud-native tools. This ensures that platforms evolve continuously while preserving developer experience and governance.

Feature flags are the most effective way to control feature exposure to specific users, such as internal testers, while enabling fast rollback without redeployment. Option B is correct because feature flags allow teams to decouple deployment from release, giving precise runtime control over feature availability. This means that once the code is deployed, the team can toggle the feature on or off for different cohorts (e.g., internal users) dynamically.

Option A (blue/green deployment) controls traffic between two environments but does not provide user-level granularity. Option C (canary deployments) gradually expose changes but focus on random subsets of users rather than targeted groups such as internal employees. Option D requires redeployment or rollback, which introduces risk and slows down incident response.

Feature flags are widely recognized in platform engineering as a core continuous delivery practice that improves safety, accelerates experimentation, and enhances resilience by enabling immediate mitigation of issues.