Learn Cloud Native & CNCF - Pre-Requisites & Learning Roadmap

#Introduction

Welcome to the Learn Cloud Native & CNCF series! This series takes you into one of the most influential open source ecosystems in modern technology: cloud native and the Cloud Native Computing Foundation (CNCF). Unlike our hands-on series, this one is conceptual — its goal is to build a complete mental model, not operational skills.

Why does episode 0 matter? Because terms like container, Kubernetes, and open source are often used without a clear meaning. Before we break down CNCF's history in episode 1, its project catalog in episodes 5 and 6, or certifications in episode 9, you need a shared vocabulary so you never get lost.

In this episode you will prepare the conceptual pre-requisites, make sure you have a tool-light learning environment, and see the six-phase roadmap of this series. Nothing needs to be installed; what matters most is the way of thinking we will build together.

Let's begin with the first step: making sure your vocabulary and learning environment are ready before this long journey starts.

#Conceptual Pre-Requisites You Need

#Containers and Kubernetes in a Nutshell

A container is a way of packaging an application together with all its dependencies so it runs consistently on any machine — from a developer's laptop to production. Kubernetes is the orchestrator that manages containers automatically: scheduling, replication, scaling, and recovery from failure. Together they are the heart of the CNCF ecosystem and will be referenced in almost every episode.

You don't need to be able to operate either of them for this series, but you must understand their role. Think of it as reading a technology map: knowing where a city is and what it's for matters more than memorizing its streets.

#Comparing Containers and Virtual Machines

One concept that often confuses beginners is the difference between a container and a virtual machine. A virtual machine carries a full operating system with its own kernel, whereas a container shares the host kernel and only wraps the application with its dependencies. Because they are lighter, containers can start in seconds and be packed more densely onto a single machine.

Kubernetes was born precisely to manage hundreds to thousands of these containers automatically. Understanding this virtualization layer will be a great help when we break down the four layers of cloud native in episode 2, especially the runtime and orchestration layers.

#Open Source and Foundations

Open source means the code can be viewed, modified, and distributed by anyone under its license. However, an open source project can die if it isn't managed well. That's where foundations come in: neutral organizations that shelter projects so they stay alive, fair, and sustainable even when a particular vendor stops being involved.

This concept of vendor neutrality will be a recurring theme throughout the series. CNCF itself is one of the largest foundations, sheltering projects such as Kubernetes, Prometheus, and OpenTelemetry.

#Basic Cloud Computing Terms

You should also feel comfortable with cloud computing terms such as IaaS, PaaS, and SaaS. The cloud native landscape we will discuss in episode 2 breaks this world into categories that resemble cloud service models. Also understand the difference between on-premises and cloud, and what a managed service means.

These pre-requisites are flexible: if a term is still unclear, just make a note of it. Every term will be explained in the relevant episode.

#The Learning Environment You Prepare

This series really needs no installation, but a few small tools will enrich your experience. Open a terminal and check whether the following tools are already available:

# make sure all three tools print their respective versions
git --version
curl --version
kubectl version --client

The kubectl version --client command only prints the client version and does not require a cluster. If kubectl is missing, don't panic — the kubectl and helm commands in this series are only realistic illustrations, not required exercises. Also have a browser ready to open landscape.cncf.io and cncf.io/projects, because those are the primary data sources throughout the series.

Besides a terminal, make sure you have a stable internet connection and a GitHub account ready to use. Many official CNCF references live on GitHub, and in episode 21 you will see how that account can be used to contribute to real projects.

#The Six-Phase Learning Roadmap

This series is made up of six phases that build on one another:

• Phase 1 — Pre-Requisites & Fundamentals (episodes 0-2): the conceptual foundation, history, and the cloud native landscape.
• Phase 2 — Organization, Governance & Project Lifecycle (episodes 3-7): CNCF's structure and project catalog.
• Phase 3 — Programs, Certifications & Initiatives (episodes 8-11): KubeCon, certifications, surveys, and project programs.
• Phase 4 — Surrounding Ecosystem & Community (episodes 12-16): the Linux Foundation, FinOps, communities, and Kubernetes governance.
• Phase 5 — Trends, Advanced Topics & Innovation (episodes 17-20): AI, platform engineering, GitOps, and the roadmap.
• Phase 6 — Conclusion & How to Get Involved (episodes 21-22): contribution and a final reflection.

Follow the phases in order. Every episode assumes you already understand the previous ones, because each builds on the foundation laid before it.

#How to Follow This Series

For the best results, set aside 15-20 minutes per episode. Note down new terms and English keywords such as graduated, incubating, sandbox, steering committee, and TAG, since they are used consistently throughout the series. Keep a small glossary of these terms along with their definitions.

Use the official sources mentioned as further reading, and don't hesitate to revisit earlier episodes when you come across a term that feels familiar but isn't clear yet. Reading a technology map is like reading a city map: revisiting locations often makes the whole region feel coherent.

#Main Reference Sources

There are four sources you will encounter repeatedly in this series:

• landscape.cncf.io — the visual map of hundreds of cloud native projects and products.
• cncf.io/projects — the official catalog of projects with their maturity levels.
• kubernetes.io — the official Kubernetes documentation, including its training section.
• opentelemetry.io — the documentation for the observability standard that was graduated in May 2026.

Remember the four domains: landscape for the map, projects for the catalog, kubernetes.io for orchestration, and opentelemetry.io for observability.

The habit of consulting these official sources will keep you from trusting information whose accuracy is unclear. As a first exercise, open landscape.cncf.io and observe the variety of categories — we'll break them down in detail in episode 2.

One more note: this series does not teach you how to operate Kubernetes; it teaches you how to understand the ecosystem Kubernetes lives in. If you later feel like practicing, the end of episode 22 will point you to suitable hands-on series, such as learning Kubernetes, Argo, Prometheus, and OpenTelemetry.

Finally, don't worry if some terms feel unfamiliar at first. Each episode stands on its own yet connects to the others, so an incomplete understanding in one episode is almost always completed in the next. Consistency in following along is worth more than speed.

#Closing

Episode 0 has built your foundation: conceptual pre-requisites about containers, Kubernetes, open source, and cloud computing, a tool-light learning environment, and the six-phase roadmap that will guide you to episode 22.

Key takeaways:

• This series is conceptual; there is no required installation.
• Understand containers and Kubernetes as the foundation of the CNCF ecosystem.
• A neutral foundation keeps open source projects alive and fair.
• Tools such as kubectl and helm are used as realistic illustrations.
• The six phases of the series flow from the fundamentals to a final reflection.
• Follow each episode in order for the best results.

In episode 1 we'll step back to the very beginning: the history, background, and why the world needed CNCF — from the container explosion in 2013, the birth of Kubernetes at Google, the founding of CNCF on December 21, 2015, to the official cloud native definition from the TOC. By understanding where this ecosystem came from, you'll digest the project catalog and programs discussed in later episodes much more easily.