Kubernetes

Kubernetes Platform Engineering

Build the internal developer platform your teams actually want: golden paths, self-service APIs with Crossplane and CRDs, GitOps at scale, and SRE-grade observability - mapped to the CNCF CNPE curriculum.

Request this training
Photo from pexels
Duration
5 days
Level
Advanced
Format
On-site
Price
On request

What to expect

Build the internal developer platform your teams actually want over five hands-on days: golden paths, self-service APIs with Crossplane and CRDs, GitOps at scale, and SRE-grade observability, mapped to the CNCF Certified Cloud Native Platform Engineer curriculum and running on your own kind cluster.

What to know before

Who it's for

  • Senior platform engineers and architects who have completed Kubernetes Fundamentals, Kubernetes Operations, and Kubernetes Security & Networking, or have equivalent hands-on production experience. Not for participants new to Kubernetes.
  • Teams ready to move from 'we run Kubernetes' to 'we run a platform other teams build on': self-service infrastructure, golden paths, and platform-level SRE practices.
  • Each participant works on their own VM with VS Code preinstalled, running a multi-node kind cluster on Docker with Cilium as the CNI. Crossplane's self-service labs target local/mock providers, so no real cloud account is needed to attend.

You'll learn to

  • Design platform architecture for scale: autoscaling, multi-tenancy, and cost management, built on distributed-systems fundamentals.
  • Build an Internal Developer Platform: golden paths, CRDs and Operators with Kubebuilder, self-service provisioning with Crossplane, and a Backstage software catalog.
  • Run GitOps and progressive delivery at platform scale, operate with SRE practices (SLOs, error budgets, DORA metrics), and enforce security policy across the whole platform.

Agenda

  1. Day 1

    • Distributed-systems fundamentals for platform teams: consensus, redundancy, and fault tolerance
    • Infrastructure as Code at scale
    • Autoscaling and right-sizing with Karpenter and KEDA
    • Multi-tenancy with virtual clusters, and cost management with FinOps/OpenCost

  2. Day 2

    • GitOps repository strategies, environment promotion, and drift detection at platform scale
    • ArgoCD and Flux in depth
    • Progressive delivery with Argo Rollouts: canary and blue-green
    • Kubernetes-native CI/CD pipeline design with Tekton and Argo Workflows

  3. Day 3

    • Designing Internal Developer Platforms and golden paths
    • Designing and building Custom Resource Definitions, and the Operator pattern with Kubebuilder
    • Self-service infrastructure provisioning with Crossplane
    • A software catalog with Backstage

  4. Day 4

    • SRE fundamentals: SLOs, error budgets, and incident management
    • DORA metrics for platform efficiency
    • The Prometheus, OpenTelemetry, Grafana, and Loki stack at platform scale, with distributed tracing
    • Diagnosing and remediating platform-level incidents

  5. Day 5

    • Policy engines and admission control: OPA/Gatekeeper and Kyverno
    • Supply-chain security: Sigstore/Cosign and SBOM
    • Workload identity and mTLS with SPIFFE/SPIRE and service mesh
    • RBAC and audit trails at platform scale

The MVJ Method

Lots of practical, hands-on teaching. Theory shows up only when you need it to unblock the next exercise.

  • Mostly hands-on. Most of the session is spent building real labs and real pipelines, not watching slides.

  • Your own cluster, not a shared sandbox. Every participant runs a real multi-node kind cluster on their own VM, so what gets built in the room is what ships on Monday.

  • Small enough that everyone drives. Groups of 4-12, so every attendee gets keyboard time.

  • You keep the runbook. Labs, scripts, and reference material go home with your team as the start of your own documentation, not a one-off slide deck.

Request this training

Tell us a bit about your team and we'll get back to you to schedule Kubernetes Platform Engineering.

Manuel Vogel-Johnson

Principal Engineer

“Platform engineering fails when it's a side project bolted onto cluster admin work. We treat it as its own discipline for the week - golden paths, self-service APIs, and the SRE practices that keep a platform trustworthy once other teams depend on it.”

Kubernetes Platform Engineering

Build the internal developer platform your teams actually want: golden paths, self-service APIs with Crossplane and CRDs, GitOps at scale, and SRE-grade observability - mapped to the CNCF CNPE curriculum.

Duration
5 days
Format
On-site
Level
Advanced
Price
On request

Learning goals

  • Design platform architecture for scale: autoscaling, multi-tenancy, and cost management, built on distributed-systems fundamentals.
  • Build an Internal Developer Platform: golden paths, CRDs and Operators with Kubebuilder, self-service provisioning with Crossplane, and a Backstage software catalog.
  • Run GitOps and progressive delivery at platform scale, operate with SRE practices (SLOs, error budgets, DORA metrics), and enforce security policy across the whole platform.

FAQs

KubernetesPlatform Engineering

Related trainings

Kubernetes5 daysBeginner to IntermediateOn-siteOn request

Kubernetes Foundations

Go from container basics to a production-shaped Kubernetes cluster: architecture, workloads, networking, storage, troubleshooting, and observability - all on your own kind cluster.

Kubernetes4 daysIntermediateOn-siteOn request

Kubernetes on AWS

Run production workloads on EKS: networking, autoscaling, GitOps deployment, and the operational habits that keep clusters calm.

Kubernetes5 daysIntermediateOn-siteOn request

Kubernetes Operations

Run and ship on a cluster you maintain yourself: kubeadm upgrades, etcd backup and restore, GitOps with ArgoCD or Flux, and progressive delivery - all on your own kind cluster.