Linux Foundation Certified Cloud Native Platform Engineering Associate

Platforms are driven by declared intent rather than by commands. You compare declarative and imperative styles, treat configuration and infrastructure as code, and structure environments from development to production.

• Imperative and declarative approaches compared
• Desired state and why it makes systems predictable
• Configuration as code and infrastructure as code
• Environment strategy: development, staging, production
• Ephemeral environments for testing
• Keeping environments consistent

You build A declarative description of an application and two environments, with the differences between them made explicit.

A platform is a set of capabilities with clear interfaces. You break one into layers, from infrastructure and orchestration to delivery, observability, security and the interface developers see, and weigh what to build and what to adopt.

• Capability layers of an internal platform
• API-first design and clear interfaces
• Reference architectures and their trade-offs
• Build, buy or adopt open source
• Making the platform optional but attractive
• Documenting what the platform offers

You build A capability map for a small platform, with an interface and an owner for each layer.

Every delivery flow begins with an integrated, tested build. You learn how CI pipelines build, test and package code, how artifacts are versioned and stored, and what makes a pipeline fast and trustworthy.

• What continuous integration is for
• Stages of a CI pipeline
• Artifacts, registries and versioning
• Trunk-based development and short-lived branches
• Fast feedback and flaky tests
• Pipeline as code

You build A pipeline definition that builds, tests and publishes a container image for a sample service.

Continuous delivery gets tested software to users safely. You see how CI and CD relate, how GitOps manages environments from Git, and how changes are promoted and rolled back.

• The relationship between CI and CD
• GitOps principles in outline
• Managing environments from a Git repository
• Promoting changes between environments
• Rolling back by reverting
• Push-based and pull-based delivery compared

You build A repository layout and promotion flow that moves one release from development to production.

Kubernetes keeps asking whether reality matches intent, and platforms build on that habit. You learn the reconciliation loop, how custom resources extend the API for self-service, and how operators provision infrastructure.

• Controllers and the reconciliation loop
• Custom resource definitions as platform APIs
• The operator pattern
• Provisioning infrastructure through Kubernetes APIs
• Composing resources into one request
• What goes wrong when reconciliation fails

You build A custom resource that requests a small piece of infrastructure, and a trace of how it reconciles.

A platform that developers cannot find or understand goes unused. You learn how portals and API-driven service catalogs give simple access to capabilities, templates and documentation, and what makes the experience good.

• Internal developer platforms and portals
• Service catalogs and API-driven provisioning
• Software templates and golden paths
• Documentation that stays with the code
• Simplifying access to platform capabilities
• Feedback loops with developers

You build A service catalog entry and a software template for a new service, designed from the developer’s point of view.

A platform’s users notice its failures first, unless you watch it. You learn what traces, metrics, logs and events each reveal, how to build useful signals, and how a platform team responds to incidents.

• Metrics, logs, traces and events compared
• Instrumentation and shared standards
• Service level indicators and objectives in outline
• Alerting that people act on
• Incident response roles and communication
• Learning from incidents

You build An observability plan for one platform capability, with signals, alerts and an incident checklist.

Security and conformance should be defaults, not requests. You learn how services authenticate each other, how policy engines enforce rules, and how to build security into CI/CD pipelines.

• Service-to-service authentication and encryption
• Policy engines and policy as code
• Security checks in CI/CD pipelines
• Secrets handling in platforms
• Conformance and audit evidence
• Balancing guardrails and freedom

You build A short policy set and a pipeline security checklist for the platform’s golden path.

A platform has to show that it helps. You learn to measure efficiency and developer productivity, apply the DORA metrics to platform work, and avoid measures that people learn to game.

• Platform efficiency and where time is lost
• The DORA metrics and how to collect them
• Developer experience and survey signals
• Adoption and satisfaction measures
• Metrics that backfire
• Reporting results to leadership and users

You build A measurement plan for a platform initiative, with each metric defined and its data source named.

AI tools now sit inside platforms and developer workflows. You learn where they help, such as assistants, operations automation and portal search, and where they need review, limits and clear accountability.

• Assistants in developer portals
• AI in operations and incident triage
• Generating configuration and its risks
• Data access and governance for AI tools
• Human review and accountability
• Evaluating whether an AI feature helps

You build A short assessment of one AI feature for a platform, with its benefits, risks and required controls.

Pick a team’s real pain and design a thin platform slice that removes it. You set goals, choose capabilities, define the delivery path, add signals and security, and decide how you will know it worked.

• Choosing the pain and the users
• Designing the capability and its interface
• Wiring delivery with GitOps
• Adding observability and security defaults
• Defining success measures
• Presenting the proposal

You build A proposal and prototype for a first platform capability, with architecture, delivery path and success measures.