Beginner 4h 30m

Build Your First Kubernetes Developer Platform

Move from GUI-driven cluster management to platform APIs, golden-path deployments, and automated operations. This path assembles modern tools that let you offer a polished developer experience on Kubernetes without drowning in YAML.

Technologies Covered

Platform EngineeringKubernetesPortainerDevStandCrossplaneHashiCorp WaypointRobustaPrometheusGitOps

Your Guides

Profile picture of David Flanagan
David Flanagan
Start Learning

Prerequisites

  • Comfortable using a command-line interface and Git.
  • Basic understanding of containers and Kubernetes primitives (Pods, Deployments, Services).
  • Access to a Kubernetes cluster (local or cloud) where you can install Helm charts and custom controllers.
  • Familiarity with Visual Studio Code or another code editor.
  • Exposure to CI/CD or GitOps workflows is helpful.

Build Your First Kubernetes Developer Platform

Move from UI-driven Kubernetes operations to opinionated platform APIs, golden-path deployments, and automated incident response. Each stop introduces a production-ready building block you can stitch together into a developer platform.

Learning Objectives

  • Apply guardrails and RBAC to simplify day-one cluster onboarding for teams.
  • Model applications with reusable templates that compile to standard Kubernetes manifests.
  • Expose cloud infrastructure as platform APIs through Crossplane compositions.
  • Deliver a consistent build → deploy → release workflow with HashiCorp Waypoint.
  • Enrich Prometheus alerts so platform engineers and developers can close the loop on incidents quickly.

Videos in This Path

1. Hands-on Introduction to Portainer

Why it matters: Portainer gives you a “manager of managers” interface so teams can safely explore Kubernetes before you expose lower-level tools.

What you’ll learn:

  • Understand the core value proposition of Portainer for simplifying container management.
  • Describe how Portainer provides a unified interface for managing diverse environments like Kubernetes, Docker, and Nomad.
  • Apply policies, RBAC, and guardrails that keep self-service access secure.
  • Deploy a containerized application from the Portainer UI to demonstrate a fast path to value.

Key takeaways:

  • Portainer has grown into a universal management plane for multi-cluster and edge environments.
  • Built-in guardrails, policy enforcement, and centralized RBAC prevent common misconfigurations while keeping workflows approachable.

2. Hands-on Introduction to DevStand

Why it matters: DevStand turns platform patterns into Jsonnet templates and a drag-and-drop VS Code experience, closing the gap between application design and Kubernetes delivery.

What you’ll learn:

  • Recognize the Kubernetes pain points DevStand abstracts for application developers.
  • Use Jsonnet-powered templates to replace verbose Kubernetes YAML.
  • Assemble a microservice architecture visually inside VS Code and generate manifests.
  • Export a single DevStand configuration that compiles to version-controlled Kubernetes resources.

Key takeaways:

  • DevStand delivers a PaaS-like experience on any Kubernetes cluster through reusable building blocks.
  • The Jsonnet source of truth keeps complex app definitions portable and reviewable while the visual canvas accelerates developer onboarding.

3. Introduction to Crossplane

Why it matters: Before you hand developers infrastructure APIs, you need a universal control plane that speaks Kubernetes and cloud. Crossplane provides the foundation.

What you’ll learn:

  • Explain how Crossplane extends the Kubernetes API to manage external infrastructure.
  • Compare Crossplane’s continuous reconciliation model with on-demand IaC tools like Terraform.
  • Install Crossplane, add a cloud provider, and explore Composite Resource Definitions (XRDs).
  • Design simplified platform APIs that hide cloud complexity behind custom resources.

Key takeaways:

  • Crossplane turns Kubernetes into a universal control plane so you can manage cloud resources with the same GitOps workflows as workloads.
  • Continuous reconciliation and compositions keep infrastructure drift-free while enforcing platform policy.

4. Crossplane in Action

Why it matters: This follow-up demonstrates how to package your abstractions into real platform building blocks that developers can consume safely.

What you’ll learn:

  • Provision cloud infrastructure using standard Kubernetes manifests and Crossplane Compositions.
  • Apply opinionated platform APIs that bundle best practices into a single custom resource.
  • Observe Crossplane’s reconciliation loop correcting drift and maintaining desired state.
  • Map RBAC and credential boundaries so teams can request infrastructure without direct cloud access.

Key takeaways:

  • Crossplane compositions let platform teams encode golden paths that stay aligned with policy and security requirements.
  • Treating infrastructure as Kubernetes objects unlocks native integrations with GitOps, policy engines, and observability stacks.

5. Hands-on Introduction to Waypoint

Why it matters: Waypoint standardizes the build → deploy → release cycle, whether teams target Lambda, Kubernetes, or another runtime—perfect for platform engineers who need a portable workflow.

What you’ll learn:

  • Install the Waypoint server locally and on Kubernetes to back your platform workflows.
  • Define applications in waypoint.hcl and plug into existing YAML or Cloud Native Buildpacks.
  • Run automated deployments to Kubernetes and AWS Lambda from the same configuration.
  • Separate deployment from release to enable progressive delivery strategies.

Key takeaways:

  • waypoint up creates a consistent developer experience across multiple execution environments.
  • Plugins and the distinct release phase give platform teams fine-grained control without rewriting pipelines per environment.

6. Monitoring Kubernetes with Prometheus & Robusta

Why it matters: A platform is only as good as its day-two operations. Robusta enriches Prometheus alerts so frontline engineers get context, not just noise.

What you’ll learn:

  • Install Robusta alongside Prometheus using Helm and connect it to Alertmanager.
  • Enrich alerts with logs, graphs, and timelines that accelerate troubleshooting.
  • Customize Robusta enrichers to collect runbook data for recurring production issues.
  • Navigate the Robusta SaaS UI for multi-cluster visibility and faster MTTR.

Key takeaways:

  • Standard Prometheus alerts lack context; Robusta automates evidence gathering to reduce alert fatigue.
  • Runbook automation keeps developers productive and closes the loop between platform engineers and the teams they support.

Where to Go Next

  • Combine DevStand blueprints and Crossplane compositions into a single GitOps repository so application and infrastructure definitions travel together.
  • Add Robusta KRR to surface resource efficiency recommendations alongside alert enrichment.
  • Pilot Waypoint pipelines with a small product team, then roll them out across environments once the workflow meets internal guardrails.