Cloud-native developer

For software developers: practise deploying, configuring and troubleshooting your own applications on a Kubernetes platform operated by others, through preparation for the separately booked Linux Foundation Certified Kubernetes Application Developer (CKAD) exam. Automated build pipelines, telemetry (measurement data), operator development and GitOps delivery are optional additions outside the core route.

Your starting point in 3 questionsView route, duration & prices

THE LEARNING PATH AT A GLANCE

Cloud-native developer: stages, scope and sequence

The route spans 5 stages, from “Prior knowledge” to “Role focus”. Workshop counts, training days and price refer to the core route.

  • 4 workshops · Core route
  • 10–11 training days · Core route
  • €5,550 to €6,105 excluding VAT · Core route

  1. Prior knowledge

    Existing experience can replace individual stations.

  2. Container foundation

    Either container foundation leads into the shared Kubernetes basics.

  3. Kubernetes basics

    Practical foundations for later role responsibilities and certification goals involving hands-on exams.

  4. Operations practice

    You deepen workload practice, scaling, access and network rules, operational signals and configuration per environment.

  5. Role focus

    This learning path follows a role path, which optional topics deepen.

Your route through this path

YOUR LEARNING PATH

The experience you bring

Check which learning steps you still need.

Find your starting point: 3 questions

TEAM ROUTE: OPTIONAL

Plan a shared training programme

Roles → skill gaps → shared plan

The result: a clear route for the whole team.

Your self-assessment

For each question, choose the answer that best describes your current situation.

Recommendation without contact details or sign-up

Goal set by this learning path

Skills, sequence, workshops

Which Kubernetes skills build on each other?

The learning steps show this path’s recommended sequence. Depending on your goal, they include specialisations, optional topics or certification goals. Each step shows the workshops that cover it.

How to read the learning path
  • Required or recommended
  • Choice
  • Optional further study
  • Further learning path

Preparation

Before starting, if needed; excluded from the workshop count, days and price.

Show 5 skills

  • Prior knowledge

    Existing experience can replace individual stations.

    • PRIOR KNOWLEDGEOptionalIF NEEDED
      Linux and network access

      Command line, processes, file system, connectivity, ports, SSH access

      You practise Linux commands, processes and file permissions, check network interfaces, connectivity and open ports, and connect to remote computers using SSH. The Linux workshop helps fill knowledge gaps; the Docker and Podman workshops introduce YAML as a configuration format.

      Afterwards, you can inspect files, permissions and processes in a Linux terminal, narrow down network problems and work on remote computers using SSH.

      If you lack Linux practice, use the Linux workshop; existing experience is sufficient. Familiarity with the Linux command line matters for CKAD preparation, and ideally you can edit YAML files.

      4 learning moves

      1. Navigate the file system

        You use shell commands to navigate directories and search file contents, so you can find your way around a Linux system.

      2. Check permissions and processes

        You check file permissions and running processes to understand access boundaries and stop unresponsive processes selectively.

      3. Examine network access

        You check network interfaces, connectivity and open ports separately to narrow down connection problems.

      4. Access remote computers with SSH

        You connect to a remote computer using SSH to apply your terminal skills on another system.

      • Prerequisite: The “Kubernetes basics” competency requires Linux and terminal fundamentals; if you already have this knowledge, you do not need the Linux workshop.
    • PRIOR KNOWLEDGEOptionalIF NEEDED
      Git and collaboration

      Commits, branches, merges, remotes, reviews

      You version changes with Git and practise collaboration through branches and reviews. Choose the Git introduction or the workshop using GitLab as its platform.

      Afterwards, you can version changes with Git, share them through branches and remotes, merge them after review and resolve merge conflicts.

      If you lack Git practice, practise commits, branches and reviews with Git or GitLab.

      4 learning moves

      1. Record changes as commits

        You trace changes from the working directory through the staging area to a commit, so you can choose what to version.

      2. Separate work with branches

        You work on changes separately in branches and compare them before bringing the work back together.

      3. Exchange changes through remotes

        You share commits through remote repositories and distinguish fetching other people's changes from integrating them.

      4. Review and merge changes

        In reviews, you discuss changes through their differences and resolve merge conflicts to combine contributions with team input.

      Choose 1 of 2

      Choose the Git workshop to start, or the GitLab workshop if your team uses GitLab.

      • Prerequisite: Working on GitLab pipelines requires Git fundamentals; existing experience can replace the introductory workshop.
      • Prerequisite: Argo CD and Flux require Git knowledge including branches and pull requests; existing experience removes the need for an additional workshop.
    • PRIOR KNOWLEDGEOptionalIF NEEDED
      Go for development

      Types, interfaces, error handling, tests, HTTP

      You apply existing programming experience to Go and practise types, interfaces, error handling and tests. This workshop is optional preparation for operator development, which starts with a Go crash course.

      Afterwards, you can structure Go code with types and interfaces, write HTTP handlers, handle errors explicitly and check behaviour with unit tests.

      If you plan to develop operators later and do not yet know Go, you can prepare here. Programming experience in another language is required; the operator workshop itself already starts with a Go crash course.

      4 learning moves

      1. Express data and functions in Go

        You apply existing programming knowledge to Go types, control flow and functions to express your first program logic.

      2. Connect behaviour through interfaces

        You model data and behaviour with structs, methods and interfaces so that code can work with different types.

      3. Handle HTTP requests

        You build HTTP handlers and process JSON data with the standard library to make Go code accessible through an HTTP interface.

      4. Handle errors and test behaviour

        You handle errors as return values and check behaviour with unit tests to account explicitly for failure cases in your code.

      • Recommended next step: A fuller introduction to Go can prepare you for operator development; the operator workshop already includes a Go crash course.

  • Container foundation

    Either container foundation leads into the shared Kubernetes basics.

    Choose 1 of 2

    Choose Podman if your team or target platform uses it or containers must run without root privileges; otherwise choose Docker.

    • CONTAINEROptionalCHOICE
      Docker fundamentals

      Images, containers, volumes, networks

      You build container images with Dockerfiles, including multi-stage builds, and run containers with persistent storage and network connections. With Docker Compose, you run related application services.

      Afterwards, you can build custom images, connect containers with persistent storage and run related application services with Docker Compose.

      If you do not yet build your own container images, add Docker practice for your CKAD goal; the Kubernetes introduction does not require container experience. CKAD covers defining, building and modifying images; the CKAD preparation agenda contains no dedicated exercise for this.

      4 learning moves

      1. Distinguish images from containers

        You start containers from images and inspect their state to distinguish the template from the running application.

      2. Build custom images

        When building images, you separate build stages from runtime contents so that build tools need not remain in the final image.

      3. Connect storage and networks

        You use volumes to retain data across container restarts and connect containers through networks so they can exchange data.

      4. Combine services with Compose

        In Docker Compose, you describe services, storage and networks with YAML and check how they work together in an application.

      • Recommended next step: Container experience helps with the Kubernetes introduction but is not a prerequisite for the fundamentals workshop.
      • Replacement route: The bundle connects Docker and Kubernetes through a shared booking and learning group instead of separate dates. It requires more prior knowledge: Linux command-line skills and development or system administration basics.
    • CONTAINERAlternativeCHOICE
      Podman fundamentals

      Rootless containers, pods, images

      You build container images with Podman and run containers without root privileges, with persistent storage and network connections. You group related containers into pods.

      Afterwards, you can build Podman images, run containers without root privileges using networking and persistent storage, and group them into pods.

      If your team uses Podman or needs containers without root privileges, choose Podman instead of Docker. Build any missing image-building skills here for your CKAD goal; the CKAD preparation agenda contains no dedicated exercise for this.

      4 learning moves

      1. Understand rootless operation

        Through Podman's architecture, you learn how containers run under your user account without a central daemon.

      2. Build and manage images

        You build images and manage them in registries to provide applications as a reusable basis for containers.

      3. Connect networking and storage

        With networks and volumes, you connect containers and retain data while checking file permissions in rootless operation.

      4. Group containers into pods

        In pods, you group related containers and check their communication across the shared network.

      • Recommended next step: Container experience helps with the Kubernetes introduction but is not a prerequisite for the fundamentals workshop.

Core route

Each number represents one workshop included in the totals, which may cover several skills.

  1. Workshop step 1 of 4:

    Kubernetes basics

    Practical foundations for later role responsibilities and certification goals involving hands-on exams.

    • KUBERNETES BASICSCore stepSelf-declaredCORE
      Kubernetes basics

      Architecture, pods, deployments, deployment strategies, services, namespaces, CoreDNS, storage and CSI, ConfigMaps, secrets, kubectl

      You deploy and expose applications with Kubernetes, then configure and inspect them using kubectl, the Kubernetes command-line tool. You also set up basic persistent storage for applications.

      Afterwards, you can deploy applications in Kubernetes, make them reachable, supply configuration and persistent storage, and inspect them with kubectl.

      If you lack Kubernetes practice, deploy an application in your own browser-lab cluster, make it accessible and investigate and fix failures with kubectl. CKAD preparation revisits fundamentals at exam pace; teams with solid Kubernetes practice can start later in the route.

      5 learning moves

      1. Understand architecture and pods

        You trace how the control plane, nodes and pods work together and use kubectl to inspect the state of your first pods.

      2. Deploy and update applications

        With deployments, you deploy applications and compare update strategies to assess their risks.

      3. Access and name resolution

        Services make pods reachable while you organise resources with namespaces and check name resolution with CoreDNS.

      4. Separate configuration from images

        Through ConfigMaps and Secrets, you supply configuration and sensitive values to pods so they remain separate from the image.

      5. Check persistent storage

        You attach volumes to pods, explain the roles of CSI and StorageClasses, and check whether data survives a pod restart.

      • Prerequisite: Working with Helm or Kustomize requires Kubernetes basics: Deployments, Services and simple YAML manifests.
  2. Workshop step 2 of 4:

    Operations practice

    You deepen workload practice, scaling, access and network rules, operational signals and configuration per environment.

    Here you deepen your knowledge of workloads, scaling, network access and basic operational signals. Each learning path specifies whether this depth is core or optional.

    • OPERATIONS PRACTICECore stepSelf-declaredCORE
      Workloads and scaling

      StatefulSets, database operators, scheduling, resource management, HPA, VPA, KEDA

      You examine stateful workloads with StatefulSets and use database operators. Through resource settings and scheduling rules, you control Pod placement. You configure autoscaling with HPA, VPA and KEDA.

      Afterwards, you can examine StatefulSets, use database operators, control pod placement and configure autoscaling with HPA, VPA and KEDA.

      As an application developer, examine how resource requests and limits, placement within the cluster (scheduling) and automatic scaling affect your application. Database operators and event-driven scaling illustrate additional platform operations tasks.

      4 learning moves

      1. Understand stateful workloads

        Using a database running as a StatefulSet, you examine why stable pod identities and persistent storage belong together.

      2. Use database operators

        You set up database operators and consider their advantages and disadvantages to assess their role in database operations.

      3. Control resources and placement

        With resource requests and scheduling rules, you control which nodes pods can run on and observe their placement.

      4. Distinguish scaling approaches

        You configure HPA, VPA and KEDA, distinguishing pod counts, resource adjustments and events as a basis for scaling.

    • OPERATIONS PRACTICECore stepSelf-declaredCORE
      Networking, access and operations

      Ingress and Gateway API overview, service mesh overview, network policies, RBAC, monitoring, logging

      You place Ingress, Gateway API and service mesh in context and practise RBAC and network policies. With Prometheus and Grafana, you set up basic monitoring; with Loki, you set up logging. Gateway API migration and controller portability are outside the practical scope.

      Afterwards, you can assess networking approaches, restrict API access and communication, and set up basic monitoring and logging for Kubernetes.

      As an application developer, examine access rights (RBAC) and network rules (NetworkPolicies) to diagnose blocked application access yourself. In the same Kubernetes Advanced workshop, you set up monitoring and logging to understand operations without taking on platform responsibility.

      4 learning moves

      1. Place routing and service mesh in context

        You compare the roles of Ingress, Gateway API and service mesh to understand their areas of use and limitations.

      2. Restrict API access and communication

        With RBAC, you restrict API actions and with network policies, communication, treating these as separate protection tasks.

      3. Collect and display metrics

        You set up Prometheus and Grafana through operators to collect cluster metrics and make them visible in dashboards.

      4. Centralise logs and configure alerts

        With Loki, you centralise cluster logs and add basic alerts to bring together indications of operational problems.

  3. Workshop step 3 of 4:
    • OPERATIONS PRACTICECore stepSelf-declaredCHOICE
      Manage manifests

      Environment configuration, reuse, Helm or Kustomize

      You structure Kubernetes configurations for different environments. Choose Helm with charts and values or Kustomize with bases, overlays and patches. Your choice covers work with one tool, not both tools.

      Afterwards, you can use Helm or Kustomize to structure reusable Kubernetes configurations, adapt them for different environments and check the generated resources.

      If you manage application configurations, choose Helm or Kustomize according to team practice and explore one tool in depth. CKAD preparation briefly introduces both, using Helm only for existing packages: install, upgrade and roll back, without writing your own charts.

      4 learning moves

      1. Identify shared and differing settings

        You distinguish shared configuration from environment differences to identify reusable parts of your manifests.

      2. Build a reusable structure

        Using Helm or Kustomize, you structure shared resources so that environment variants build on the same foundation.

      3. Implement environment variants

        In your chosen tool, you make targeted adjustments for staging and production so that each environment receives its own configuration.

      4. Check generated resources

        You inspect generated resources to check how shared settings and adjustments interact, helping you identify configuration errors.

      Choose 1 of 2

      Helm packages, versions and releases software as charts; Kustomize adapts existing manifests per environment with template-free overlays.

      • Recommended next step: Charts or overlays provide a basis for the configuration reconciled by Argo CD or Flux.
  4. Workshop step 4 of 4:

    Role focus

    This learning path follows a role path, which optional topics deepen.

    • ROLE PATHCore stepROLE PATH
      Development

      Ship, configure and debug applications.

      From here, the focus is on deploying, configuring and debugging applications.

    • ROLE COMPETENCYCore stepSelf-declaredROLE PATH
      Develop and debug workloads

      Probes, resources, debugging, rollouts

      You deploy and configure applications, including health checks (probes) and resource settings, and systematically diagnose rollout failures. This prepares you for the Certified Kubernetes Application Developer (CKAD) exam; attendance is not certification.

      Afterwards, you can configure workloads, use probes and resource settings, control rollouts and systematically investigate faults with kubectl.

      With Kubernetes fundamentals in place, deepen your practice with patterns for cooperating containers and explore additional topics: tasks and schedules (Jobs and CronJobs), application identities and security settings (ServiceAccounts and SecurityContexts), network rules and external access (NetworkPolicies and Ingress), plus using custom resource types. CKAD preparation revisits fundamentals at exam pace using direct kubectl commands and includes an exam simulation; book the exam separately.

      4 learning moves

      1. Build and configure workloads

        You create pods and deployments and supply configuration to manage application execution separately from its settings.

      2. Assess health and resources

        Through probes and resource settings, you examine how Kubernetes responds to application health and where resource limits take effect.

      3. Control rollouts

        Using deployments, you practise updates and rollbacks so that you can trace and control transitions between application versions.

      4. Isolate faults using evidence

        For faulty pods and rollouts, you inspect logs, status and resource limits to narrow down possible causes systematically.

      • DW5 CKAD Exam Preparationdeepened and practised hands-onIntermediate3 daysOnline, taught in GermanCKAD: Performance-based exam, 120 min, registration only USD 445 (one retake included), as of 4 August 2026; book and pay separately with the Linux Foundation, excluded from shown prices.
      • Prerequisite: Practised deployment, configuration and troubleshooting provide the basis for running your own applications on an existing Kubernetes cluster.
      5 more relationships
      • Recommended next step: The development role path deepens this competency.
      • Optional further study: If you develop HTTP services, you can extend Kubernetes application practice with instrumentation and telemetry pipelines.
      • Optional further study: You can deepen application practice through custom resources and your own Kubernetes controller.
      • Optional further study: You can complement application practice with image builds and checks in GitLab pipelines.
      • Optional further study: You can automate application delivery with Argo CD or Flux.

Possible goals

This path builds the technical foundation for these goals.

  • GoalRun your own applicationsIn preparation for Certified Kubernetes Application Developer (CKAD), you practise deploying, exposing, configuring and debugging your own applications on provided clusters; Helm or Kustomize adds configuration per environment. Cluster administration is excluded; book and pay for the exam separately with the Linux Foundation.

Further study

Optional further study; excluded from the workshop count, days and price.

Show 5 skills

  • Role focus

    This learning path follows a role path, which optional topics deepen.

    • ROLE COMPETENCYOptionalOPTIONAL
      Automate container image builds

      GitLab CI/CD: build, test and deliver, pipelines, runners for job execution, build outputs, security checks, test environments

      You create GitLab pipelines, control jobs, and build and publish container images. To these pipelines, you add scans and deployment steps and investigate pipeline failures. Git fundamentals are required.

      Afterwards, you can create GitLab pipelines to build, scan and publish container images, integrate test environments and diagnose job failures.

      If you own the build pipeline, build and publish container images with GitLab CI/CD and add checks, independently of CKAD preparation and optionally before it. Teams wanting pipelines inside the cluster can request a Tekton introduction; no public dates are listed.

      4 learning moves

      1. Match jobs to runners

        You structure a GitLab pipeline into jobs and stages and assign runners to make the sequence and execution location clear.

      2. Publish images and build outputs

        You build container images for the registry and pass build outputs as artifacts so that subsequent jobs can use them.

      3. Integrate checks and test environments

        With scan jobs and deployments to test environments, you check images and applications within the delivery workflow.

      4. Diagnose pipeline failures

        Syntax checks and job logs help you distinguish configuration errors from runner, image access and permission problems.

      2 more relationships
      • Recommended next step: A pipeline or Flux image automation writes the new image version's reference to Git; Argo CD or Flux deploys the application from that Git revision.
      • Optional further study: For build and test pipelines running directly inside Kubernetes, you can request a Tekton introduction; this execution alternative does not replace GitLab CI/CD competency.
    • DEPTH COMPETENCYOptionalON REQUEST
      Pipelines with Tekton

      Tekton, automated builds and tests, Kubernetes resources, tasks, pipelines

      Tekton runs automated build and test pipelines as Kubernetes resources inside the cluster, providing an alternative way to run continuous integration (CI). You can request an introduction to Tekton; it does not replace the GitLab CI/CD competency.

      If your development team wants to manage build and test tasks as Kubernetes resources, the Tekton introduction on request fits as optional depth after pipeline practice. It complements the GitLab step for continuous integration and delivery but does not replace it.

      • DW51 Introduction to TektonWorkshop on requestRequest
    • ROLE COMPETENCYOptionalOPTIONAL
      Automate delivery

      Reconciliation, deviations, environments, secrets without plaintext in Git, Argo CD or Flux

      With Argo CD or Flux, you deploy applications from Git and reconcile the managed Kubernetes resources with their desired state. You detect and correct deviations from the configuration in Git.

      Afterwards, you can deploy applications from Git with Argo CD or Flux, separate environments, integrate secrets without plaintext in Git and correct drift.

      If you own application deployments, choose Argo CD or Flux according to team practice, independently of the CKAD exam. Here you connect the image pipeline and application configuration to automated delivery from Git (GitOps); Helm or Kustomize are covered, with no prior knowledge of those tools required.

      4 learning moves

      1. Understand Git as the desired state

        You follow how Argo CD or Flux retrieves configuration from Git and reconciles managed resources with that desired state.

      2. Separate configuration by environment

        Shared base configuration and targeted adjustments separate differences between environments without copying every manifest.

      3. Deliver secrets without plaintext

        You compare encryption in the repository with fetching external secrets so that confidential values are not stored as plaintext in Git.

      4. Investigate drift and failures

        Using Git configuration and controller feedback, you investigate failed reconciliations and correct deviations.

      Choose 1 of 2

      Use your team's tool; Argo CD for canary and blue-green with Argo Rollouts and a browser overview, Flux for automatic image updates in Git.

    • DEPTH COMPETENCYOptionalDEPTH
      Traces and telemetry

      OpenTelemetry, instrumentation, context propagation, Collector, Tempo, export failures

      You instrument HTTP web services with OpenTelemetry and propagate context across services. In the Collector, you process traces, metrics and logs through separate signal pipelines; in Grafana, you investigate their relationships and diagnose export failures. You need HTTP development experience, confidence with terminal, YAML and containers, knowledge of Pods, Deployments and Services, plus basic Go, Node.js using JavaScript or TypeScript, Python or Java.

      Afterwards, you can instrument HTTP services, trace requests across services and use connected signals to distinguish application faults from telemetry failures.

      If you develop HTTP services and investigate their failures in production, add telemetry (measurement data); prerequisites are service development experience, basic knowledge of Go, Node.js using JavaScript or TypeScript, Python or Java, Kubernetes fundamentals and confidence with terminal, YAML and containers. You can additionally request preparation for the OpenTelemetry Certified Associate (OTCA) exam; book the exam separately.

      5 learning moves

      1. Understand the telemetry path

        You map API, SDK, Collector and backends along the data flow to distinguish how telemetry is generated, processed and stored.

      2. Instrument requests with context

        You extend automatic spans with business context and check context propagation so requests remain traceable across service boundaries.

      3. Process signals in the Collector

        Separate Collector pipelines for traces, metrics and logs reveal how each signal is received, processed and exported.

      4. Connect telemetry for diagnosis

        In Grafana, you connect traces from Tempo with metrics and logs to investigate unusual service behaviour through individual requests.

      5. Isolate export failures

        Using queues, retries and Collector metrics, you distinguish telemetry export failures from faults in the application.

      • DW11 Introduction to OpenTelemetryIntermediate3 daysOnline, taught in German
      • DW40 OpenTelemetry Certified Associate (OTCA)Exam preparation on requestOTCA: Multiple-choice, 90 min, registration only USD 250 (one retake included), as of 16 September 2026; book and pay separately with the Linux Foundation, excluded from shown prices.Request
    • DEPTH COMPETENCYOptionalDEPTH
      Develop operators

      CRDs, Kubebuilder, reconciliation, finalizers, webhooks, envtest

      You develop a Kubernetes operator with Go and Kubebuilder to manage custom resources: you model them, reconcile desired and actual state and test with envtest. A short Go introduction is included; solid Kubernetes knowledge, Linux command-line practice and a basic understanding of building container images are required.

      Afterwards, you can develop an operator with Go and Kubebuilder that validates custom resources, reconciles state and manages cleanup, and test its logic with envtest.

      If your team extends Kubernetes with custom resources and controllers, develop an operator here. Solid Kubernetes practice, Linux command-line experience and an understanding of container image builds are required; prior Go knowledge is optional because the workshop starts with a crash course.

      5 learning moves

      1. Model custom resources

        Using Go and Kubebuilder, you model CRDs and distinguish desired state from status as the foundation of your operator API.

      2. Reconcile state repeatedly

        You implement reconciliation so that repeated calls align desired and actual state without creating duplicate resources.

      3. Clean up dependent resources

        Owner references and finalizers help you associate dependent objects with their owner and perform required cleanup before deletion.

      4. Validate inputs and apply defaults

        With admission webhooks, you validate inputs and apply defaults so that your operator logic works with valid resources.

      5. Test reconciliation against the API

        With envtest, you test your reconciliation logic against a real Kubernetes API to detect errors in how it reconciles state.

Which workshops make up the Cloud-native developer example route?

The example route includes DW2, DW3, DW5 and choose between DW9 or DW22. It covers these skills: Kubernetes basics, Workloads and scaling, Networking, access and operations, Manage manifests and Develop and debug workloads.

EXAMPLE ROUTE (ROLE PATH: DEVELOPMENT)

Cloud-native developer

For software developers: practise deploying, configuring and troubleshooting your own applications on a Kubernetes platform operated by others, through preparation for the separately booked Linux Foundation Certified Kubernetes Application Developer (CKAD) exam. Automated build pipelines, telemetry (measurement data), operator development and GitOps delivery are optional additions outside the core route.

Route scope
4
Training days
10–11
List price basis, per person, excl. VAT
€5,550–€6,105
View the starting workshop for Introduction to Kubernetes (DW2)

Included in the totals: DW2, DW3, DW9 or DW22 (one workshop) and DW5. Additional workshops are excluded.

Workshops in this example route

Each workshop shows its role, skills covered and planning details.

4 workshops, recommended technical sequence

Preparation

Preparation if needed

Excluded from the workshop count, days and price.

Core route

  1. STARTING POINT (KUBERNETES BASICS)

    DW2 Introduction to Kubernetes

    If you lack Kubernetes practice, deploy an application in your own browser-lab cluster, make it accessible and investigate and fix failures with kubectl. CKAD preparation revisits fundamentals at exam pace; teams with solid Kubernetes practice can start later in the route.

    SKILLS COVERED

    Architecture, pods, deployments, deployment strategies, services, namespaces, CoreDNS, storage and CSI, ConfigMaps, secrets, kubectl

    3 days, €1,665 excluding VAT

    Choose a date

    Content & dates for Introduction to Kubernetes (DW2)

  2. OPERATIONS PRACTICE

    DW3 Advanced Kubernetes

    As an application developer, examine how resource requests and limits, placement within the cluster (scheduling) and automatic scaling affect your application. Database operators and event-driven scaling illustrate additional platform operations tasks.

    SKILLS COVERED

    StatefulSets, database operators, scheduling, resource management, HPA, VPA, KEDA, Ingress and Gateway API overview, service mesh overview, network policies, RBAC, monitoring, logging

    2 days, €1,110 excluding VAT

    Choose a date

    Content & dates for Advanced Kubernetes (DW3)

  3. CHOICE STEP

    Manage manifests

    Choose 1 of 2

    If you manage application configurations, choose Helm or Kustomize according to team practice and explore one tool in depth. CKAD preparation briefly introduces both, using Helm only for existing packages: install, upgrade and roll back, without writing your own charts.

    SKILLS COVERED

    Environment configuration, reuse, Helm or Kustomize

  4. ROLE COMPETENCY

    DW5 CKAD Exam Preparation

    With Kubernetes fundamentals in place, deepen your practice with patterns for cooperating containers and explore additional topics: tasks and schedules (Jobs and CronJobs), application identities and security settings (ServiceAccounts and SecurityContexts), network rules and external access (NetworkPolicies and Ingress), plus using custom resource types. CKAD preparation revisits fundamentals at exam pace using direct kubectl commands and includes an exam simulation; book the exam separately.

    SKILLS COVERED

    Probes, resources, debugging, rollouts

    3 days, €1,665 excluding VAT

    Choose a date

    Content & dates for CKAD Exam Preparation (DW5)

Further study

Optional further study

Excluded from the workshop count, days and price.
  • DW14 Introduction to GitLab CI/CD

    If you own the build pipeline, build and publish container images with GitLab CI/CD and add checks, independently of CKAD preparation and optionally before it. Teams wanting pipelines inside the cluster can request a Tekton introduction; no public dates are listed.

    2 days, €1,110 excluding VAT

    Content & dates for Introduction to GitLab CI/CD (DW14)
  • Automate delivery

    If needed: 1 of 2

    If you own application deployments, choose Argo CD or Flux according to team practice, independently of the CKAD exam. Here you connect the image pipeline and application configuration to automated delivery from Git (GitOps); Helm or Kustomize are covered, with no prior knowledge of those tools required.

  • DW11 Introduction to OpenTelemetry

    If you develop HTTP services and investigate their failures in production, add telemetry (measurement data); prerequisites are service development experience, basic knowledge of Go, Node.js using JavaScript or TypeScript, Python or Java, Kubernetes fundamentals and confidence with terminal, YAML and containers. You can additionally request preparation for the OpenTelemetry Certified Associate (OTCA) exam; book the exam separately.

    3 days, €1,665 excluding VAT

    Content & dates for Introduction to OpenTelemetry (DW11)
Show 1 more workshop
  • DW15 Develop Kubernetes Operators with Go

    If your team extends Kubernetes with custom resources and controllers, develop an operator here. Solid Kubernetes practice, Linux command-line experience and an understanding of container image builds are required; prior Go knowledge is optional because the workshop starts with a crash course.

    3 days, €1,665 excluding VAT

    Content & dates for Develop Kubernetes Operators with Go (DW15)

Why is this route structured this way?

The route follows learning questions: each station builds on the previous one. Here, we explain why the transitions make sense.

Recommended learning sequence, not formal exam eligibility.

The route principle

Each station answers a different learning question.

  1. Understand Kubernetes

    How do you deploy applications on Kubernetes?

  2. Understand applications in clusters

    How do resources, scaling and access rules affect your own application?

  3. Manage manifests

    How do you adapt application configurations (manifests) to different environments?

  4. Deploy and debug applications

    How do you deploy applications and troubleshoot failures under realistic CKAD exam conditions?

The learning rationale in detail

Brief explanations clarify the transitions without repeating the route.

  1. DW2 then DW3: Competence prerequisite

    Why does Kubernetes Advanced belong in a developer path towards CKAD preparation?

    Kubernetes Advanced explores resources, scaling and access rules affecting your application, overlapping with CKAD topics in configuration, security and networking, although it is not an exam course. Knowledge of the Kubernetes introduction's topics is required. If you know these through extensive practical experience, attending the introductory workshop is not a formal entry requirement.

  2. DW3 then DW9 / DW22: Recommended order

    Why gain cluster practice before Helm or Kustomize?

    Cluster practice helps you understand configurations; this order is recommended, not required. Choose Helm for reusable application packages or Kustomize for a shared base configuration with adjustments for each environment.

  3. DW9 / DW22 then DW5: Exam preparation

    Why practise Helm or Kustomize before CKAD preparation?

    CKAD preparation briefly introduces Helm for using existing packages without writing charts, and Kustomize; deeper practice with one tool makes these topics easier and is recommended. Kubernetes fundamentals and development or administration experience are required; Linux knowledge matters, and ideally you can edit YAML files. For the CKAD goal, we also recommend image-building practice because the CKAD preparation agenda contains no dedicated exercise for this.

What is fixed, what is flexible?

The status shows which core stations contribute to the totals and where prior knowledge or learning goals allow flexibility. Optional additions count only when selected.

  • Included in this route

    This station belongs to the core route with an assigned workshop.

  • Choice of equivalent workshops

    Choose one of the offered workshops; scope, duration and price may differ.

  • Equivalent alternative

    Choose Podman instead of Docker if your team already works with Podman.

  • Optional

    This addition falls outside the standard scope and pricing basis; book it only for team members who need it.

  • On request

    Workshops and exam preparation on request: no public dates or prices, excluded from totals; scope, language, format and price agreed after a discovery call. Requests are not bookings or exam registrations; book and pay for exams separately with the Linux Foundation.

Sources for this route

Agenda · Practice lab · Exam body · checked on

View methodology and sources

How does the roadmap lead to practical experience?

The roadmap sets out competency goals and sequence; the workshop agenda shows the content. In practical workshops, you apply that knowledge in the browser-based Dojo. The certificate of attendance documents workshop participation but does not replace proof of passing an exam; exams for CKAD are taken separately through the Linux Foundation or CNCF.

From learning goal to application

4 clear steps

  1. Competency goal

    The learning goal describes a concrete task.

  2. Workshop agenda

    Content and sequence are clear.

  3. Dojo practice

    In practical workshops, you apply knowledge in Dojo exercises.

  4. Application & context

    The certificate of attendance documents participation, not certification.

What “covered” means and how we substantiate it

4 criteria: directly supported

  • Visible

    Content is transparent

    “Covered” is an editorial classification of the visible workshop agenda, not proof of assessed competence.

  • Structured

    The sequence is explained

    The agenda arranges topics in a clear learning sequence.

  • Applied

    Knowledge is applied in practice

    In practical workshops, you apply knowledge through exercises in the browser-based Dojo.

  • Distinguished

    Records remain separate

    The certificate of attendance and proof of passing an exam remain separate.

Reviewed by the expert team at DevNinjas GmbH

Sources checked on

Which Kubernetes learning path fits your goal?

Compare related paths by their skills and technical focus. Check each workshop’s prerequisites before booking.

Kubernetes Administrator

For administrators and operations teams with Linux experience: you practise building and maintaining Kubernetes clusters and fixing faults. The path prepares you for the Certified Kubernetes Administrator (CKA) exam, booked separately with the Linux Foundation. Optional depth follows your team responsibilities.

  • ALTERNATIVE ROLE PATH
  • Core route 12 days
  • 4 workshops
  • ROLE PATH: OPERATIONS

A good fit if you want to build on the same foundations with a different technical focus.

Core routes compared

In both core routes

  • Kubernetes basicsStart
  • Workloads and scaling
  • Networking, access and operations

Only in this core route

  • Manage software with Helm
  • Cluster operations and troubleshooting
Explore the Kubernetes Administrator learning path
Compare all Kubernetes learning paths

Frequently asked questions about the Kubernetes learning path

A learning path is a recommended sequence, with no obligation to book it all. The right workshops depend on your container knowledge, target role and practical experience. The displayed duration and price refer to the core route.

CKAD or CKA: which preparation suits my development role?

If you develop Kubernetes applications, Certified Kubernetes Application Developer (CKAD) preparation fits that work: you practise tasks such as supplying configuration through ConfigMaps and Secrets.

If you also take responsibility for cluster setup and recovery, consider Certified Kubernetes Administrator (CKA) preparation. The Kubernetes certification guide compares the exam goals.

Must I already know Go for the Cloud-Native Developer learning path?

Go knowledge is not required for the Cloud-Native Developer core route. CKAD preparation requires development or systems administration experience, but no particular programming language.

The optional operator development workshop with Go begins with a Go crash course. It requires solid Kubernetes knowledge and hands-on programming experience in Go or another language. The Golang workshop offers a fuller language introduction, also for participants with programming experience in another language.

Must I have administered Kubernetes clusters before CKAD preparation?

CKAD preparation does not require cluster administration experience; software development is also a suitable professional background. CKAD preparation requires Kubernetes knowledge and experience with Linux and the command line.

Development skills alone do not cover those foundations. The learning-path overview covers costs and scheduling for any additional preparation.

Which programming languages can I use in the OpenTelemetry workshop?

The OpenTelemetry workshop supports Go, Node.js with JavaScript or TypeScript, Python and Java. You need knowledge of your chosen language; you do not need to know the others.

The OpenTelemetry introduction also describes the terminal, YAML and container experience you need.

Vincent Sturm, Key Account Manager

Discuss your team’s learning path with Vincent

Discuss goals, roles, timing, format and suitable workshop sequences with Vincent. You can explore technical questions with our trainers afterwards if needed.
View public workshop dates