Skip to main content
Welcome back. This short, optional refresher covers core concepts you’ll rely on in platform engineering: containerization, Kubernetes basics, Git fundamentals, and how GitOps ties them together. If you already use these technologies daily, feel free to mark this complete. Otherwise, this article will quickly rebuild your confidence and point you to further reading.
This is a high-level refresher intended to rebuild confidence. It is not a complete deep dive — take the dedicated Kubernetes for the Absolute Beginners - Hands-on Tutorial or GIT for Beginners courses if you need more detail.

​
Containerization basics: containers vs virtual machines

Virtual machines use hypervisor-based OS virtualization: each VM boots a full operating system with its own kernel and userland. That provides strong isolation but increases resource overhead and startup time.
A presentation slide titled "Understanding Containerization" showing a diagram of a Hypervisor above three virtual machine blocks labeled Windows, Linux, and macOS with OS layers beneath them.
Containers, by contrast, are process-level virtualization. They package an application and its user-space dependencies while sharing the host kernel. This makes container images smaller, faster to start, and more portable across environments that share the same OS kernel and CPU architecture. Key constraints to remember:
  • Containers share the host kernel: Linux containers need a Linux kernel; Windows containers need a Windows kernel.
  • CPU architecture matters: images built for x86_64 won’t run on ARM hosts without cross-building or emulation.
Containers are portable across similar OS and architecture families but are not OS-agnostic. Always match your container image OS/architecture to the target host.
A presentation slide titled "Understanding Containerization" showing several "Container" blocks surrounding a highlighted "Host OS Kernel" block. Accompanying text explains that containers share the host OS kernel, package apps with their dependencies into portable units, and are faster and more efficient.
Because containers include the runtime and dependencies, they greatly reduce the “it works on my machine” problem: the same image a developer builds locally can run in testing, staging, or production—so long as the target environment supports the same kernel and architecture.
A slide titled "Understanding Containerization" showing four colored monitor icons labeled Developer, Testing, Staging, and Production, each containing a small container symbol. The caption reads "Containers enable scalable, consistent applications" and mentions eliminating the "it works on my machine" problem.
At scale, platform engineers must manage:
  • Autoscaling and capacity planning
  • Safe rollouts and rollbacks
  • Continuous health monitoring and observability
While Docker made containers easy for developers, production-grade reliability requires orchestration.
A presentation slide titled "Understanding Containerization." It shows three colored icons with captions: "Scale during traffic spikes," "Roll out updates safely," and "Ensure they stay healthy."

​
What is Kubernetes? — orchestration for containerized apps

Kubernetes is the leading open-source system for automating deployment, scaling, and management of containerized applications. It orchestrates containers across a cluster, providing features such as self-healing, rolling updates, horizontal autoscaling, and resource scheduling. For platform engineering, Kubernetes is often the runtime layer that enables self-service and operational controls.
An infographic titled "Essential Kubernetes Components" showing a central Kubernetes logo surrounded by labeled icons for Namespace, Cluster, Service, Pod, and Deployment with short descriptions of each. It visually summarizes key Kubernetes concepts like isolation (namespace), compute capacity (cluster), stable network access (service), pods, and deployments.
Core Kubernetes objects and their roles: Common operational commands used in platform engineering:
For more details, see the official Kubernetes documentation: https://kubernetes.io/docs/

​
Git fundamentals and Infrastructure as Code (IaC)

Git is a distributed version control system used to track changes, collaborate, and store history. Platform engineering relies on Git to version-control deployment manifests, configuration, and infrastructure-as-code templates so changes are auditable, reversible, and automatable. Typical Git workflow (concise):
A slide titled "Git – The Foundation of Modern Deployment" showing three colored icons labeled Infrastructure-as-Code, Configuration Files, and Deployment Manifests inside a box with a caption "Gets versioned in Git." The KodeKloud copyright appears at the bottom.
Useful Git resources:

​
GitOps: Git as the single source of truth

GitOps is an operational model where Git repositories hold the declarative desired state for infrastructure and applications. Automated controllers (GitOps agents) observe Git and reconcile the cluster’s actual state to match the desired state stored in Git. This makes deployments auditable, reproducible, and observable. Key benefits:
  • Declarative deployments and rollbacks
  • Clear audit trail (who changed what and when)
  • Faster recovery via reverting commits
Caveat: configuration drift can still happen if manual changes are made directly to clusters. GitOps lowers that risk by making Git the primary change channel.
A slide titled "Git Commands in Platform Engineering" showing a flowchart where a platform engineer updates a Kubernetes deployment manifest, pushes it to Git, GitOps detects the changes, and the changes are applied to production.
Recommended GitOps controllers and resources:

​
Core tools that power platform engineering

Containers, Kubernetes, Git, and GitOps are the backbone of many platform engineering initiatives. Around them, platform teams integrate supporting capabilities to create a reliable, self-service developer platform:
  • Service catalogs and platform APIs
  • Observability (metrics, traces, logs)
  • Security: vulnerability scanning, runtime protection
  • Cost management and autoscaling controls
  • CI/CD pipelines and image registries
A slide titled "Tools That Power Platform Engineering" showing five numbered items—Containers, Kubernetes, Git, GitOps, and Platform—each with a short description of its role.
This lesson establishes the foundations. From here, explore deeper topics in upcoming lessons: service catalogs, security and compliance, observability, autoscaling, and creating developer self-service. Thanks for reading.

Watch Video