Kubestronaut

KCNA, CKAD, CKA, KCSA and CKS preparation with optional practical fundamentals. The Kubestronaut goal requires active certifications. The Golden stage follows with preparation on request.

Your starting point in 3 questionsView route, duration & prices

THE LEARNING PATH AT A GLANCE

Kubestronaut: stages, scope and sequence

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

  • 5 workshops · Core route
  • 16 training days · Core route
  • €8,880 excluding VAT · Core route

  1. Prior knowledge

    Existing experience can replace individual stations.

  2. Kubernetes basics

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

  3. Operations practice

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

  4. Role focus

    All 3 role paths belong to this learning path.

  5. Towards Golden Kubestronaut

    Further certifications build on Kubestronaut and are excluded from the displayed days and prices.

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 4 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.

      Add Linux and terminal fundamentals here if you lack them for the practical workshops; KCNA preparation does not require them. The Golden stage's Linux system administration credential builds on this area at administrator level; this introduction is not exam preparation.

      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.

  • Kubernetes basics

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

    • KUBERNETES BASICSOptionalOPTIONAL
      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 fundamentals, practise working with pods, deployments and services here. Preparation for application development (CKAD), cluster administration (CKA) and security fundamentals (KCSA) assumes these skills; equivalent practical experience also counts.

      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.

      • Optional further study: Preparation for Kubernetes and Cloud Native Associate (KCNA) adds theory and exam questions to Kubernetes basics; it can come before or after it and does not replace practice.

  • Operations practice

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

    BOTH OPTIONAL

    These competencies deepen the learning path and are optional.

    • OPERATIONS PRACTICEOptionalOPTIONAL
      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.

      The optional Kubernetes Advanced workshop deepens scheduling and resource management skills for later CKAD, CKA and CKS preparation. It also covers the networking and storage station and is charged as a shared workshop.

      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 PRACTICEOptionalOPTIONAL
      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.

      Optionally deepen role-based access control and network policy skills that recur in CKAD, CKA and CKS preparation. Like the workload station, this station belongs to Kubernetes Advanced; it does not create an additional workshop booking.

      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.

Core route

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

  1. Workshop step 1 of 5:

    Kubernetes basics

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

    • CLOUD NATIVE KNOWLEDGECore stepSelf-declaredCONCEPTS
      Cloud native concepts

      Architecture, API objects, container runtimes, CNCF, observability, delivery

      You place Kubernetes and the cloud native ecosystem in context and work through KCNA sample questions. Prior Kubernetes practice is not required; this preparation does not replace a practical introduction to Kubernetes.

      Afterwards, you can explain Kubernetes components and cloud native concepts, classify scenarios and identify learning gaps for KCNA preparation.

      You study concepts and practise sample questions for the Kubernetes and Cloud Native Associate (KCNA), a multiple-choice knowledge exam. No Kubernetes practice is required; the workshop does not replace a practical introduction.

      4 learning moves

      1. Place architecture and runtimes in context

        You distinguish the roles of the control plane, worker nodes and container runtimes to understand orchestration.

      2. Match API objects to their tasks

        Using scenarios, you match pods, deployments and services to their tasks and explain how these API objects work together.

      3. Understand cloud native responsibilities

        Within the CNCF ecosystem, you assess architectural approaches and distinguish observability of systems from delivery of changes.

      4. Test concepts and identify learning gaps

        With KCNA sample questions, you check your understanding and use incorrect answers to identify concepts that need further study.

      • DW24 KCNA Exam PreparationConcepts, sample questions and a mock examBeginner2 daysOnline, taught in GermanKCNA: Multiple-choice, 90 min, registration only USD 250 (one retake included), as of 9 October 2026; book and pay separately with the Linux Foundation, excluded from shown prices.
      2 more relationships
      • Recommended next step: Kubernetes basics adds practice to theoretical preparation for Kubernetes and Cloud Native Associate (KCNA); it can come before or after it.
      • Certification: KCNA is among the certifications listed for the Kubestronaut goal; preparation does not replace the exam.
  2. Workshop step 2 of 5:

    Role focus

    All 3 role paths belong to this learning path.

    COMPLETE ALL 3 ROLE PATHS

    • ROLE PATHCore stepROLE PATH
      Development

      Ship, configure and debug applications.

      Deploying, configuring and debugging applications: your focus on the way to the CKAD exam.

    • 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.

      You practise deploying, configuring and debugging applications to prepare for the separately booked Certified Kubernetes Application Developer (CKAD) exam. Kubernetes fundamentals and development or administration experience are required. Initial Linux command line skills are also important; ideally, you are comfortable with a text editor or IDE and can edit YAML files.

      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.
      3 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 automate application delivery with Argo CD or Flux.
  3. Workshop step 3 of 5:
    • ROLE PATHCore stepROLE PATH
      Administration

      Operate clusters and narrow down failures systematically.

      Operating clusters and investigating failures systematically: your focus on the way to the CKA exam.

    • ROLE COMPETENCYCore stepSelf-declaredROLE PATH
      Cluster operations and troubleshooting

      kubeadm, container runtimes, etcd backup and recovery, CNI, scheduling, storage, RBAC, upgrades, troubleshooting

      Certified Kubernetes Administrator (CKA) preparation requires system administration or DevOps practice. You practise kubeadm cluster setup, upgrades, etcd backup and recovery, and diagnose network, application, storage and access faults. Passing CKA is required for the Certified Kubernetes Security Specialist (CKS) exam.

      Afterwards, you can build clusters with kubeadm, perform upgrades, back up and restore etcd, and systematically isolate operational faults.

      You practise cluster setup, upgrades, backup, recovery and troubleshooting to prepare for the separately booked Certified Kubernetes Administrator (CKA) exam. Entry requires Kubernetes fundamentals, system administration or DevOps experience, and confident use of the Linux command line, an editor and YAML.

      5 learning moves

      1. Connect cluster components

        When building a cluster with kubeadm, you relate the control plane, container runtimes and CNI to control, execution and networking.

      2. Control placement and storage

        Using scheduling rules and persistent storage, you practise controlling where pods run and how stateful applications receive storage.

      3. Limit access with RBAC

        You assign appropriate permissions to users and service accounts through RBAC to define allowed API actions and their scope.

      4. Practise upgrades and recovery

        You practise ordered cluster upgrades, etcd backups and recovery to understand changes and the return to a backed-up state.

      5. Isolate faults by affected layer

        For network, application, storage and access faults, you separate symptoms from causes to test focused diagnostic hypotheses.

      • DW6 CKA Exam Preparationcovered in depth and practised with exam-like tasksIntermediate4 daysOnline, taught in GermanCKA: 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: CKS preparation requires production cluster administration practice: allow time for this and the CKA exam. The Linux Foundation requires a passed CKA for the CKS exam, even with an expired credential; preparation alone does not qualify.
      3 more relationships
      • Recommended next step: The administration role path deepens this competency.
      • Optional further study: If your team uses Cilium, extend general networking practice with identity-based access rules, flow diagnostics using Hubble and encryption between nodes with WireGuard.
      • Optional further study: If your team needs control between application services, Istio extends general networking basics with encrypted, mutually authenticated connections, access rules and traffic management.
  4. Workshop step 4 of 5:
    • ROLE PATHCore stepROLE PATH
      Security

      Secure the cluster and the software supply chain.

      Understanding security concepts, hardening clusters and securing software supply chains: your focus on the way to KCSA and CKS.

    • ROLE COMPETENCYCore stepSelf-declaredROLE PATH
      Security fundamentals

      Security across cloud, cluster, container and code, control plane, Pod protection, access rights, threats, audit logs

      You practise safeguards and exam questions for Kubernetes and Cloud Native Security Associate (KCSA). Overview: runtime detection, admission policies, image scans, supply chains, certificate infrastructure and compliance. Required: Kubernetes and networking basics, Linux command-line practice; no substitute for cluster experience or practical security exam (CKS) prerequisites.

      Afterwards, you can explain safeguards for cloud-native systems, apply basic access and Pod policies and assess security signals.

      You study security fundamentals for the separately booked Kubernetes and Cloud Native Security Associate (KCSA) exam. Entry requires Kubernetes fundamentals, Linux command line skills and networking concepts; CKA certification is not required.

      4 learning moves

      1. Map security layers and threats

        You map threats to the cloud, cluster, container and code layers to understand responsibilities and security boundaries.

      2. Protect the control plane and access

        Using the API Server, etcd and RBAC, you examine how authentication, permissions and encryption protect cluster access.

      3. Apply Pod and network policies

        You test Pod protection and network policies to restrict disallowed container settings and unwanted connections.

      4. Assess security signals

        Image scans, runtime alerts and audit logs help you distinguish vulnerabilities from suspicious activity and API access.

      • DW25 KCSA Exam PreparationSecurity fundamentals with exercises and KCSA exam preparationIntermediate3 daysOnline, taught in GermanKCSA: Multiple-choice, 90 min, registration only USD 250 (one retake included), as of 4 August 2026; book and pay separately with the Linux Foundation, excluded from shown prices.
      6 more relationships
      • Recommended next step: The security role path first examines security layers and threats in Kubernetes.
      • Recommended next step: The security fundamentals establish context before deeper hardening; KCSA is not a prerequisite for CKS.
      • Optional further study: You can implement Kubernetes controls as tested policies with Kyverno or OPA Gatekeeper.
      • Optional further study: For targeted network segmentation with Cilium, extend basic network policies with identity-based access and use Hubble to verify allowed and blocked connections.
      • Optional further study: If your team needs to secure service communication, use Istio to practise mutual authentication, encryption and access rules and investigate failures beyond the security overview.
      • Certification: KCSA is among the certifications listed for the Kubestronaut goal; preparation does not replace the exam.
  5. Workshop step 5 of 5:
    • ROLE COMPETENCYCore stepSelf-declaredROLE PATH
      Secure the cluster and supply chain

      Hardening against CIS (Center for Internet Security), policies, secrets such as passwords, runtime, software supply chain, audit logs, forensics

      For Certified Kubernetes Security Specialist (CKS), you practise CIS benchmark hardening: AppArmor, seccomp, Pod Security, etcd encryption and default-deny network policies. You also work with software bills of materials, image signing, admission and vulnerability checks, OpenID Connect authentication, Falco runtime detection and incident analysis using audit logs.

      Afterwards, you can harden Kubernetes components, check images before admission and investigate security incidents using runtime data and audit logs.

      You practise hardening, runtime security and software supply chain protection in CKS preparation. Booking requires a previously passed CKA exam (even if the certification has since expired), production Kubernetes administration experience, confident Linux use and network security fundamentals.

      5 learning moves

      1. Harden the cluster and access

        You check cluster components against CIS benchmarks and restrict access rights to identify weaknesses and unnecessary permissions.

      2. Protect Pods, secrets and networks

        You restrict container access with Pod Security, AppArmor, seccomp and network policies; etcd encryption protects stored secrets.

      3. Check images before admission

        You use bills of materials, signatures and vulnerability scans to check images and enforce admission rules for their use.

      4. Detect suspicious activity

        Falco rules detect suspicious runtime behaviour, while audit logs record critical API access for investigation.

      5. Contain and reconstruct incidents

        You isolate suspicious Pods and examine audit logs and forensic data to trace attack paths and causes.

      • DW7 CKS Exam Preparationdeepened and practised hands-onAdvanced4 daysOnline, taught in GermanCKS: 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.

Possible goals

This path builds the technical foundation for these goals.

  • GoalKubestronautActive certifications, not workshop attendances. The personal Cloud Native Computing Foundation (CNCF) title cannot be earned by splitting exams across a team. It lapses at the end of the year in which a required certification expires unless that certification is renewed.The Golden Kubestronaut goal builds on the Kubestronaut credentials; its further credentials follow in the next stage of this learning path.

Further study

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

Show 17 skills

  • Towards Golden Kubestronaut

    Further certifications build on Kubestronaut and are excluded from the displayed days and prices.

    The personal Golden Kubestronaut title awarded by the CNCF requires every certification listed here in addition to the Kubestronaut certifications. The bookable technology workshops are not exam preparation and are neither required nor sufficient on their own for the respective exam.

    Adapt the order to your experience: the practical platform exam connects delivery, infrastructure automation, observability and security. Showing the Linux group afterwards does not prescribe a mandatory learning sequence.

    Observe system behaviour

    How does your team collect telemetry, detect failures and trace their causes across service boundaries?

    • GOLDEN KUBESTRONAUTOptionalON REQUEST
      Prometheus monitoring (PCA)

      Prometheus architecture, PromQL, instrumentation, service discovery, alerting, monitoring

      The Prometheus Certified Associate (PCA) exam assesses Prometheus monitoring, queries and instrumentation. The monitoring workshop practises operations, queries and alerting and also covers Grafana and Loki. It is not dedicated PCA exam preparation. Preparation is on request; book and pay for the exam separately with the Linux Foundation.

      Here you compare your Prometheus knowledge with the PCA exam scope. The monitoring workshop provides relevant operational practice but is not dedicated exam preparation. Discuss any additional learning needs when requesting PCA preparation.

      • DW41 Prometheus Certified Associate (PCA)Exam preparation on requestPCA: 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
      Metrics, logs and alerting

      Prometheus, Grafana, Loki, dashboards, alerting

      With Prometheus, Grafana and Loki, you collect and analyse metrics and logs from Kubernetes. You create dashboards, configure alerts and define measurable service objectives. During incidents, you combine signals and also investigate data gaps and resource problems in the monitoring stack.

      Afterwards, you can analyse Kubernetes metrics and logs with Prometheus, Grafana and Loki, configure dashboards and alerts and investigate incidents systematically.

      The bookable advanced workshop practises Prometheus operations, PromQL and Alertmanager alongside Grafana and Loki, supporting parts of PCA. It requires cluster administration experience and is not dedicated exam preparation.

      4 learning moves

      1. Collect metrics and logs

        You collect metrics with Prometheus and logs with Loki to understand measurements and events as different sources of information.

      2. Query and combine data

        With PromQL and LogQL, you select relevant data and combine it in Grafana dashboards to examine anomalies in context.

      3. Define alerts and service objectives

        You formulate measurable service objectives and configure alert rules and recipients so that critical conditions become visible.

      4. Investigate incidents using signals

        You trace incidents from alerts through dashboards to logs, also checking data gaps and resource problems in the monitoring stack.

      • Optional further study: With experience developing HTTP services, you extend the operations perspective with application telemetry and traces.
    • GOLDEN KUBESTRONAUTOptionalON REQUEST
      Telemetry with OpenTelemetry (OTCA)

      Instrumentation, Collector processing, telemetry export, context correlation

      The OpenTelemetry Certified Associate (OTCA) exam assesses instrumentation, Collector processing, export and context propagation. The OpenTelemetry workshop practises these workflows, but provides no dedicated exam preparation. Preparation is on request; book and pay for the exam separately with the Linux Foundation.

      After monitoring, this step follows telemetry from the application through to export. Use OpenTelemetry practice as a subject foundation and request separate OTCA preparation if needed.

      • 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
      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.

      The bookable OpenTelemetry workshop practises instrumentation, Collector use and context propagation for OTCA, but provides no exam preparation. It requires HTTP service development experience and basic knowledge of Go, Node.js (JavaScript/TypeScript), Python or Java.

      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.

    Networking and service mesh

    How does your team control, protect and investigate communication between applications in the cluster?

    • GOLDEN KUBESTRONAUTOptionalON REQUEST
      Networking with Cilium (CCA)

      eBPF, Cilium networking, policies, service mesh, network observability

      The Cilium Certified Associate (CCA) exam assesses Cilium networking, policies and service meshes. The Cilium workshop practises networking, policies and troubleshooting with Hubble, but excludes Cilium service mesh. Preparation is on request; book and pay for the exam separately with the Linux Foundation.

      Here you extend Cilium networking practice to the exam scope, including service mesh. That gap remains after the Cilium workshop; dedicated CCA preparation is on request.

      • DW39 Cilium Certified Associate (CCA)Exam preparation on requestCCA: 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
      Cluster networking with Cilium

      Cilium, Hubble, L3/L4/L7 policies, FQDN egress, kube-proxy replacement, WireGuard

      You configure Cilium, follow network flows with Hubble and restrict access with policies. The work also involves examining kube-proxy replacement, WireGuard encryption between nodes and data path failures. eBPF programming is not a prerequisite.

      Afterwards, you can configure Cilium, restrict network access with policies and use Hubble and diagnostic data to isolate faults in service paths and rules.

      The bookable Cilium workshop practises networking, policies and troubleshooting with Hubble for CCA, but excludes Cilium service mesh. It requires Kubernetes experience and networking fundamentals and is not exam preparation.

      5 learning moves

      1. Place Cilium in the data path

        You check installation prerequisites and trace Pod and Service paths to understand Cilium's role in routing and load balancing.

      2. Inspect communication with Hubble

        Hubble flows reveal sources, destinations and dropped connections so you can identify required communication before restricting it.

      3. Restrict network access deliberately

        You test identity, port, HTTP and FQDN egress rules with allowed and denied requests to verify their effect on access.

      4. Check service paths and encryption

        With kube-proxy replacement and WireGuard, you check service paths and encryption boundaries to understand these operational options.

      5. Isolate data path faults

        You combine status, Hubble flows and endpoint data into a diagnostic path that extends to eBPF programs and Cilium maps when needed.

    • GOLDEN KUBESTRONAUTOptionalON REQUEST
      Service mesh with Istio (ICA)

      Traffic management, security, resilience, observability

      The Istio Certified Associate (ICA) exam assesses configuring and explaining traffic management, security, resilience and observability. The Istio workshop practises this service mesh work, but provides no dedicated exam preparation. Preparation is on request; book and pay for the exam separately with the Linux Foundation.

      This step combines explaining Istio concepts with configuring them in practice. The Istio workshop provides relevant tool practice; request dedicated ICA preparation separately.

      • DW42 Istio Certified Associate (ICA)Exam preparation on requestICA: Performance-based exam / Multiple-choice, 120 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
      Service mesh with Istio

      Istio, traffic management, mTLS, authorization policies, JWT, troubleshooting

      You configure Istio for communication between services and external access. This includes practising mTLS, access controls and traffic management and examining service mesh operations. This focus does not replace an in-depth Gateway API migration workshop.

      Afterwards, you can use Istio to route service traffic, secure connections and access, and investigate causes of communication failures.

      The bookable Istio workshop practises traffic management, security and troubleshooting, supporting ICA’s practical tasks; it provides no dedicated exam preparation. It requires Kubernetes experience, Kubernetes networking fundamentals and confidence with kubectl and the Linux command line.

      4 learning moves

      1. Understand responsibilities in the mesh

        The roles of Istiod and Envoy explain how Istio distributes configuration and controls communication between services.

      2. Direct traffic deliberately

        Routing rules and a gateway let you direct requests to service versions and enable external access.

      3. Secure connections and access

        You combine mTLS, authorization policies and JWT validation to encrypt connections and define which requests are allowed.

      4. Investigate failures across services

        Metrics, traces and proxy configurations help you investigate the causes of delayed or rejected requests in the mesh.

    Deliver software

    How does your team automate delivery from Git and reconcile running systems with their desired state?

    • GOLDEN KUBESTRONAUTOptionalON REQUEST
      GitOps principles (CGOA)

      Declarative configuration, reconciliation, delivery, security, tooling

      The Certified GitOps Associate (CGOA) exam assesses tool-neutral principles of declarative delivery and reconciliation. The Argo CD or Flux workshops practise these principles with a specific tool, but do not replace tool-neutral exam preparation. Preparation is on request; book and pay for the exam separately with the Linux Foundation.

      Place your delivery practice in the context of tool-neutral GitOps principles. Argo CD or Flux provide relevant examples; request CGOA preparation for the broader exam scope.

      • DW44 Certified GitOps Associate (CGOA)Exam preparation on requestCGOA: 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
    • GOLDEN KUBESTRONAUTOptionalON REQUEST
      Delivery with Argo (CAPA)

      Argo Workflows, Argo CD, Argo Rollouts, Argo Events, GitOps delivery

      The Certified Argo Project Associate (CAPA) exam assesses knowledge across the Argo project. The Argo CD workshop practises Argo CD and Argo Rollouts, excluding Argo Workflows and Argo Events; Flux does not help here. Preparation is on request; book and pay for the exam separately with the Linux Foundation.

      This step focuses on the whole Argo project. The Argo CD workshop supports Argo CD and Argo Rollouts, leaving Argo Workflows and Argo Events uncovered; Flux does not support CAPA, and dedicated preparation is on request.

      • DW43 Certified Argo Project Associate (CAPA)Exam preparation on requestCAPA: 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
    • 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.

      Argo CD or Flux practise GitOps for CGOA; only Argo CD and Rollouts support CAPA, excluding Workflows and Events. These bookable workshops require Kubernetes and Git knowledge; they are not exam preparation.

      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.

    Policy and platforms

    How does your team implement required policies and provide development platforms with self-service?

    • GOLDEN KUBESTRONAUTOptionalON REQUEST
      Policies with Kyverno (KCA)

      Validate resources, mutate resources, generate resources, verify images, review results

      The Kyverno Certified Associate (KCA) exam assesses resource policies, image verification and policy results. The Kyverno workshop practises these tasks, but provides no dedicated exam preparation; OPA Gatekeeper does not prepare for KCA. Preparation is on request; book and pay for the exam separately with the Linux Foundation.

      Here you assess knowledge of Kyverno policies and their results. Choose Kyverno for supporting tool practice; OPA Gatekeeper does not cover this credential, and dedicated KCA preparation remains separately available on request.

      • DW45 Kyverno Certified Associate (KCA)Exam preparation on requestKCA: 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 COMPETENCYOptionalCHOICE
      Policy as code

      Admission control, validation, mutation, exceptions, policy tests, CI

      You develop and test Kubernetes policies with Kyverno or OPA Gatekeeper and Rego. This includes examining validation, mutation and exception handling and integrating tests into CI. Git and CI fundamentals are required; the feature scope depends on the selected tool.

      Afterwards, you can develop Kubernetes policies with the selected tool, test them in CI and prepare their enforcement with narrowly scoped exceptions.

      Only Kyverno practises policies and image verification relevant to KCA; OPA Gatekeeper does not prepare for KCA. These bookable workshops require Kubernetes experience, Git branches and basic CI experience; they are not exam preparation.

      4 learning moves

      1. Understand admission and resource checks

        You distinguish checks on new API requests from checks on existing resources to understand the reach of a policy.

      2. Design validation and mutation

        With the selected tool, you define validation rules and limited mutations to check requirements or supply missing values.

      3. Test rules and integrate CI checks

        Allowed, violating and excluded resources become CI test cases so unintended policy behaviour is detected before deployment.

      4. Scope exceptions and enforcement

        Narrowly scoped exceptions and reviewed check results help you make an informed transition from observing violations to blocking them.

      Choose 1 of 2

      Gatekeeper with Open Policy Agent (OPA) for existing use or a deliberate Rego choice, otherwise Kyverno for YAML policies; only Kyverno aligns with requestable Kyverno Certified Associate preparation.

    • GOLDEN KUBESTRONAUTOptionalON REQUEST
      Developer portals with Backstage (CBA)

      Software catalog, templates, plugins, TechDocs, search, authentication

      The Certified Backstage Associate (CBA) exam assesses knowledge of Backstage’s software catalog, templates, plugins, documentation, search and authentication. There is no matching published technology workshop; you can also request a Backstage introduction. Preparation is on request; book and pay for the exam separately with the Linux Foundation.

      Backstage shifts the focus to accessing software, documentation and templates through a developer portal. For your platform team, you can request a Backstage introduction or dedicated CBA preparation; the introduction is not exam preparation.

      • DW46 Certified Backstage Associate (CBA)Exam preparation on requestCBA: 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
      • DW52 Introduction to BackstageWorkshop on requestRequest
    • GOLDEN KUBESTRONAUTOptionalON REQUEST
      Platform concepts (CNPA)

      Platform architecture, self-service, automation, observability, security

      The Certified Cloud Native Platform Engineering Associate (CNPA) exam assesses concepts for platform architecture, self-service, automation, observability and security. There is no matching published technology workshop here. Preparation is on request; book and pay for the exam separately with the Linux Foundation.

      Bring architecture, self-service and operational requirements together in a platform concept. This conceptual step is recommended before CNPE but is not a formal prerequisite; with no matching published workshop, preparation remains on request.

      • DW47 Certified Cloud Native Platform Engineering Associate (CNPA)Exam preparation on requestCNPA: Multiple-choice, 120 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
    • GOLDEN KUBESTRONAUTOptionalON REQUEST
      Build platforms (CNPE)

      Self-service platforms, delivery, infrastructure automation, observability, security

      The Certified Cloud Native Platform Engineer (CNPE) exam assesses building self-service platforms with delivery, infrastructure automation, observability and security. There is no matching published technology workshop here. Preparation is on request; book and pay for the exam separately with the Linux Foundation.

      CNPE connects delivery, infrastructure automation, observability and security in practical platform building within the “Policy and platforms” group. CNPA is not a formal prerequisite; no matching published workshop is available, and dedicated preparation is on request.

      • DW48 Certified Cloud Native Platform Engineer (CNPE)Exam preparation on requestCNPE: Performance-based exam, 120 min, registration only USD 445 (one retake included), as of 16 September 2026; book and pay separately with the Linux Foundation, excluded from shown prices.Request

    Administer Linux

    How does your team manage Linux users, services, networks and storage and investigate operational failures?

    • GOLDEN KUBESTRONAUTOptionalON REQUEST
      Linux administration (LFCS)

      Users, services, networking, storage, troubleshooting

      The Linux Foundation Certified System Administrator (LFCS) exam assesses practical administration of users, services, networks and storage, plus troubleshooting. The earlier Linux introduction teaches foundations, but neither storage administration nor exam preparation. Preparation is on request; book and pay for the exam separately with the Linux Foundation.

      This Linux Foundation credential deepens system administration from your CKA practice, independently of the CNCF topic groups. The earlier Linux introduction remains a foundation; storage administration and dedicated LFCS preparation go beyond it.

      • DW49 Linux Foundation Certified System Administrator (LFCS)Exam preparation on requestLFCS: Performance-based exam, 120 min, registration only USD 445 (one retake included), as of 18 September 2026; book and pay separately with the Linux Foundation, excluded from shown prices.Request

Possible goals

This path builds the technical foundation for these goals.

  • GoalGolden KubestronautKubestronaut plus further CNCF-listed credentials plus LFCS: a personal title awarded for life.Each listed credential counts as a certification on the Golden Kubestronaut roster. Preparation does not replace an exam; workshop attendance and DevNinjas attendance certificates do not count.

Which workshops make up the Kubestronaut example route?

The example route includes DW24, DW5, DW6, DW25 and DW7. It covers these skills: Cloud native concepts, Develop and debug workloads, Cluster operations and troubleshooting, Security fundamentals and Secure the cluster and supply chain.

EXAMPLE ROUTE (CERTIFICATION GOAL)

Kubestronaut

KCNA, CKAD, CKA, KCSA and CKS preparation with optional practical fundamentals. The Kubestronaut goal requires active certifications. The Golden stage follows with preparation on request.

Route scope
5
Training days
16
List price basis, per person, excl. VAT
€8,880
View the starting workshop for KCNA Exam Preparation (DW24)

Included in the totals: DW24, DW5, DW6, DW25 and DW7. Additional workshops are excluded.

Workshops in this example route

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

5 workshops, recommended technical sequence

Preparation

Preparation if needed

Excluded from the workshop count, days and price.
  • DW2 Introduction to Kubernetes

    If you lack Kubernetes fundamentals, practise working with pods, deployments and services here. Preparation for application development (CKAD), cluster administration (CKA) and security fundamentals (KCSA) assumes these skills; equivalent practical experience also counts.

    3 days, €1,665 excluding VAT

    Content & dates for Introduction to Kubernetes (DW2)
  • DW3 Advanced Kubernetes

    The optional Kubernetes Advanced workshop deepens scheduling and resource management skills for later CKAD, CKA and CKS preparation. It also covers the networking and storage station and is charged as a shared workshop.

    2 days, €1,110 excluding VAT

    Content & dates for Advanced Kubernetes (DW3)

Core route

  1. STARTING POINT (CLOUD NATIVE KNOWLEDGE)

    DW24 KCNA Exam Preparation

    You study concepts and practise sample questions for the Kubernetes and Cloud Native Associate (KCNA), a multiple-choice knowledge exam. No Kubernetes practice is required; the workshop does not replace a practical introduction.

    SKILLS COVERED

    Architecture, API objects, container runtimes, CNCF, observability, delivery

    2 days, €1,110 excluding VAT

    Choose a date

    Content & dates for KCNA Exam Preparation (DW24)

  2. ROLE COMPETENCY

    DW5 CKAD Exam Preparation

    You practise deploying, configuring and debugging applications to prepare for the separately booked Certified Kubernetes Application Developer (CKAD) exam. Kubernetes fundamentals and development or administration experience are required. Initial Linux command line skills are also important; ideally, you are comfortable with a text editor or IDE and can edit YAML files.

    SKILLS COVERED

    Probes, resources, debugging, rollouts

    3 days, €1,665 excluding VAT

    Choose a date

    Content & dates for CKAD Exam Preparation (DW5)

  3. ROLE COMPETENCY

    DW6 CKA Exam Preparation

    You practise cluster setup, upgrades, backup, recovery and troubleshooting to prepare for the separately booked Certified Kubernetes Administrator (CKA) exam. Entry requires Kubernetes fundamentals, system administration or DevOps experience, and confident use of the Linux command line, an editor and YAML.

    SKILLS COVERED

    kubeadm, container runtimes, etcd backup and recovery, CNI, scheduling, storage, RBAC, upgrades, troubleshooting

    4 days, €2,220 excluding VAT

    Choose a date

    Content & dates for CKA Exam Preparation (DW6)

  4. ROLE COMPETENCY

    DW25 KCSA Exam Preparation

    You study security fundamentals for the separately booked Kubernetes and Cloud Native Security Associate (KCSA) exam. Entry requires Kubernetes fundamentals, Linux command line skills and networking concepts; CKA certification is not required.

    SKILLS COVERED

    Security across cloud, cluster, container and code, control plane, Pod protection, access rights, threats, audit logs

    3 days, €1,665 excluding VAT

    Choose a date

    Content & dates for KCSA Exam Preparation (DW25)

  5. ROLE COMPETENCY

    DW7 CKS Exam Preparation

    You practise hardening, runtime security and software supply chain protection in CKS preparation. Booking requires a previously passed CKA exam (even if the certification has since expired), production Kubernetes administration experience, confident Linux use and network security fundamentals.

    SKILLS COVERED

    Hardening against CIS (Center for Internet Security), policies, secrets such as passwords, runtime, software supply chain, audit logs, forensics

    4 days, €2,220 excluding VAT

    Choose a date

    Content & dates for CKS Exam Preparation (DW7)

Further study

Optional further study

Excluded from the workshop count, days and price.
  • DW10 Kubernetes Monitoring and Observability

    The bookable advanced workshop practises Prometheus operations, PromQL and Alertmanager alongside Grafana and Loki, supporting parts of PCA. It requires cluster administration experience and is not dedicated exam preparation.

    4 days, €2,220 excluding VAT

    Content & dates for Kubernetes Monitoring and Observability (DW10)
  • DW11 Introduction to OpenTelemetry

    The bookable OpenTelemetry workshop practises instrumentation, Collector use and context propagation for OTCA, but provides no exam preparation. It requires HTTP service development experience and basic knowledge of Go, Node.js (JavaScript/TypeScript), Python or Java.

    3 days, €1,665 excluding VAT

    Content & dates for Introduction to OpenTelemetry (DW11)
  • DW32 Introduction to Cilium

    The bookable Cilium workshop practises networking, policies and troubleshooting with Hubble for CCA, but excludes Cilium service mesh. It requires Kubernetes experience and networking fundamentals and is not exam preparation.

    3 days, €1,665 excluding VAT

    Content & dates for Introduction to Cilium (DW32)
Show 5 more workshops
  • DW16 Introduction to Istio and Service Mesh

    The bookable Istio workshop practises traffic management, security and troubleshooting, supporting ICA’s practical tasks; it provides no dedicated exam preparation. It requires Kubernetes experience, Kubernetes networking fundamentals and confidence with kubectl and the Linux command line.

    3 days, €1,665 excluding VAT

    Content & dates for Introduction to Istio and Service Mesh (DW16)
  • Policy as code

    If needed: 1 of 2

    Only Kyverno practises policies and image verification relevant to KCA; OPA Gatekeeper does not prepare for KCA. These bookable workshops require Kubernetes experience, Git branches and basic CI experience; they are not exam preparation.

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; the formal exam prerequisite is marked in the legend.

The route principle

Each station answers a different learning question.

  1. Understand the ecosystem

    Where does Kubernetes fit within cloud-native computing?

  2. Deploy applications

    How do you configure applications and investigate failures?

  3. Operate clusters

    How do you build, upgrade and repair clusters?

  4. Deepen security knowledge

    How do you secure clusters and software supply chains?

The learning rationale in detail

Brief explanations clarify the transitions without repeating the route.

  1. DW24 then DW5: Competence prerequisite

    Why does CKAD preparation need more than KCNA concepts?

    The KCNA workshop introduces cloud-native concepts; in the CKAD workshop, you practise application deployment and debugging. This requires Kubernetes fundamentals and experience in software development or system administration. Initial Linux command line skills are also important; ideally, you are comfortable with a text editor or IDE and can edit YAML files. Equivalent prior knowledge counts regardless of whether you attended preparatory workshops.

  2. DW5 then DW6: Recommended order

    Why do cluster operations follow application work?

    Application work in the CKAD workshop shows what a cluster must provide, giving context for setup, upgrades and recovery in the CKA workshop. This order is recommended and can be reversed with suitable prior knowledge. Regardless of order, the CKA workshop requires Kubernetes fundamentals, system administration or DevOps experience, and confident use of the Linux command line, an editor and YAML.

  3. DW25 then DW7: Recommended order

    What is recommended before CKS, and which prerequisite is mandatory?

    KCSA fundamentals support deeper hardening but are only recommended. The Linux Foundation requires a previously passed CKA exam before the CKS exam, even if that certification has since expired. The CKS workshop additionally requires experience administering production Kubernetes clusters, confident Linux use and network security fundamentals.

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

    A workshop included in the core route: the DevNinjas certificate of attendance is not a certification; you book and pay for the exam separately with the Linux Foundation.

  • Optional

    An additional bookable workshop outside the standard scope and price. The Golden stage also includes these optional technology workshops: they teach the tool, are not exam preparation and are neither exam prerequisites nor sufficient on their own. Separate exam preparations are available there on request.

  • Formal exam prerequisite

    The Linux Foundation sets this exam prerequisite; you book and pay for the exam separately with them.

  • 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 KCNA, CKAD, CKA, KCSA and CKS 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.

GitOps and Continuous Delivery

For development, DevOps and platform teams: practise traceable delivery through Git. Kubernetes is followed by Helm or Kustomize, GitLab CI/CD and Argo CD or Flux; preparation and advanced monitoring are optional.

  • ALTERNATIVE ROLE PATH
  • Core route 10 to 11 days
  • 4 workshops
  • ROLE PATH: DELIVERY

A good fit if you want a different technical focus suited to your work.

Core routes compared

Only in this core route

  • Kubernetes basicsStart
  • Manage manifests
  • Automate container image builds
  • Automate delivery
Explore the GitOps and Continuous Delivery 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.

How should I schedule exams for the Kubestronaut goal?

The CNCF Kubestronaut programme requires five certifications to be valid simultaneously: Kubernetes and Cloud Native Associate (KCNA), Certified Kubernetes Application Developer (CKAD), Certified Kubernetes Administrator (CKA), Kubernetes and Cloud Native Security Associate (KCSA) and Certified Kubernetes Security Specialist (CKS).

The learning path starts with KCNA foundations, then moves through application practice and administration to security. Schedule exams according to your progress so that their validity periods overlap. The Kubernetes certification guide explains the rules.

Can I start the Kubestronaut path without Kubernetes experience?

You can start the Kubestronaut learning path through KCNA preparation without practical Kubernetes experience. KCNA preparation requires basic IT infrastructure knowledge; Linux terminal and programming skills are not required for this entry point.

Later workshops require additional practical experience. The learning-path overview distinguishes standard-route training days from additional preparation to help you plan the commitment for your starting point.

How does the learning path finder account for exams already passed?

The personal learning path finder can provisionally skip exam preparation when you report the corresponding certification as currently active. If it has expired or its validity is unclear, preparation remains in the plan.

The learning path finder does not check certificates, verify knowledge or decide exam eligibility. You can restore skipped stations. Attendance prerequisites for the remaining workshops apply regardless of the result.

Is Golden Kubestronaut included in the Kubestronaut learning path?

Golden Kubestronaut, the advanced tier of the CNCF programme, appears as a follow-on stage and is excluded from the standard route, its training days and its price.

An exam preparation enquiry first leads to a discussion and a proposal covering scope, price and language. The Kubernetes certification guide explains which additional certifications the title requires.

What should I plan for Kubestronaut exams and renewals?

For Kubestronaut, exams booked separately with the Linux Foundation add to workshop costs; renewals may bring further costs. Exam fees are not included in workshop prices.

The Linux Foundation renewal programme can extend certain certifications you already hold through an advanced exam. The Kubernetes certification guide explains fees and renewal rules to help you account for them in your budget.

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