After this training, you will:
• Understand why frequent, automated deployments reduce risk and how to measure your team’s success with DORA metrics.
• Explain the crucial concept of a “desired state” and a “reconciliation loop”.
• Apply the “Everything is a file” philosophy to create a version-controlled workflow.
• Design a CI pipeline that builds, versions, and pushes containerized artifacts.
• Understand the core concepts behind Kubernetes’ success and how to get started.
• Implement a GitOps workflow to declaratively manage application state in Kubernetes.
In modern software engineering, it’s not only about writing code, but delivering it reliably, securely, and at speed. The key is to make deployments small, frequent, and automated. This is a proven way to reduce risks. This course provides a blueprint for that process, built on two timeless principles: the control systems concept of a “reconciliation loop” and philosophy of “Everything is a file”.
We demystify complex topics like Kubernetes operators by comparing them to real-world control systems, like the software that keeps a robot in balance. You will not just learn some commands; you will understand the fundamental principles of declarative systems. This enables you to design more resilient and elegant solutions, and understand the “why” behind the industry shift towards cloud-native technologies.
This course is for builders and maintainers of software systems. No prior Kubernetes knowledge is required.
• Software Developers & Engineers who want to understand what it looks like to build and deliver applications in a cloud native way.
• Architects and Engineers considering a move to Kubernetes, who want to learn the core concepts and the reasons for its industry-wide adoption.
• DevOps and Platform Engineers responsible for creating and managing CI/CD infrastructure.
• Technically-skilled Test Engineers who want to deepen their understanding of the underlying platform they interact with.
Day 1: The Foundation – Why We Automate and How
• Module 1: The Goal: High-Velocity, Low-Risk Deployments
o Why deploying frequently is safer than deploying rarely.
o Introduction to the four key DORA metrics as our measure of success.
o The mindset shift: From executing steps to describing a Desired State.
• Module 2: The “Everything is a File” Principle in Practice
o The Linux philosophy and its application to modern DevOps.
o Why your Git repos are the single source of truth for code, tests, and infrastructure.
o Hands-on Lab: Creating a GitHub Actions workflow that builds and pushes a versioned container image, proving the “file to artifact” concept.
• Module 3: Ephemeral Environments as a Quality Gate
o The power of dynamic, on-demand preview environments for every pull request.
o How to run a full suite of tests (integration, end-to-end) against a real, production-like environment.
o Live Demo: Blocking a pull request from being merged to main until all tests have passed in its own ephemeral environment.
Day 2: The Delivery Engine – Desired State & Reconciliation
• Module 4: Describing Desired State with Kubernetes
o A practical introduction to the core concepts for developers, starting from scratch.
o Defining your application’s desired state using Kubernetes objects (Deployments, Services, ConfigMaps).
o Hands-on Lab: Manually applying a desired state to a cluster.
• Module 5: Understanding the Reconciliation Loop
o The “Balancing Robot” analogy: Understanding control loops.
o How a Kubernetes operator works: The power of continuous reconciliation.
o How Terraform uses the same principle to manage infrastructure.
• Module 6: GitOps: The Ultimate Reconciliation Workflow
o GitOps as the perfect implementation of the “desired state” principle.
o Hands-on Lab: Using a tool like ArgoCD to connect your Git repository to Kubernetes and achieve a fully declarative, self-healing deployment.
o Closing “the loop”: from a desired state change in Git to a reconciled state in production.
Your starting point to CNCF Certification
The Cloud Native Computing Foundation (CNCF) is the vendor-neutral home of foundational open-source projects like Kubernetes. Their certifications are the global standard for cloud-native expertise.
While this course is not a dedicated exam preparation, it provides the conceptual understanding that forms the foundation for pursuing certifications. After this training, you will be prepared to start studying for the CKAD (Certified Kubernetes Application Developer) exam.
• Duration: 2 Days
• Language: English / Dutch
• Prerequisites: Solid understanding of Git. Some familiarity with container concepts (Docker) and the command line is expected. No prior Kubernetes knowledge is required.
• What to bring: A laptop with a container runtime (e.g., Docker Desktop), VSCode, and a personal GitHub account.
As a software engineer and entrepreneur, Simon Koudijs focuses on a practical goal: building quality software that is delivered reliably. His background in Electrical Engineering taught him to measure and solve problems in small steps; a skillset he has applied everywhere, from embedded programming and small startups to large companies like the pension fund PGGM.
In his daily work, he builds a software product. He uses modern AI tools to get the job done, but isn’t one to be fooled by the hype. This training is based on that hands-on experience. You’ll learn the practical skills and the “why” behind them, so you can confidently apply these methods to build better software, faster.
