Crawl, Walk, Run: Containers for Leaders (Beyond Just the Tech)

Why This Matters

Every few years, technology gives us a step-change — not a trend, not a fad, but a new baseline for how modern organizations operate.

Containers are that baseline today.

Join the conversation! Follow The Code to Cloud podcast and become part of our cloud-native community.

They aren’t new. They aren’t risky. They aren’t experimental.

Their lineage goes back 40+ years — UNIX chroot in 1979, Linux containers in 2008, Docker in 2013 — and Kubernetes plus Azure Kubernetes Service (AKS) have turned them into a production-ready foundation used by nearly every digital-first company today.

For leaders, it comes down to four things:

speed, consistency, portability, and resilience.

If cloud VMs standardized infrastructure, then:

• Containers standardize the application package, and

• Kubernetes standardizes how that package runs at scale

This is the next chapter of operational maturity — the one that unlocks everything else.

⸻

The Crawl, Walk, Run Journey

⸻

Crawl — Build Clarity, Confidence, and Culture

Start by creating a shared language.

A container is simply a lightweight, isolated package containing your app and its dependencies. It runs the same way everywhere — laptop, cloud, edge.

Unlike VMs, containers share the host OS kernel.

This isn’t just efficiency; it’s operational simplicity.

Empower developers and platform engineers to up-skill faster with AI-driven tools like GitHub Copilot.

Normalize the history. Containers aren’t a disruption — they’re an evolution.

Use the cloud VM analogy leaders already understand:

Containers don’t change your application — they change how you package and run it.

Introduce OCI Early

The Open Container Initiative (OCI) is what makes containers portable and vendor-neutral. It defines:

• Image Specification

• Runtime Specification

• Distribution Specification

OCI is the USB standard of containers: build an image once, run it anywhere Kubernetes runs.

A Quick Win to Build Momentum

Pick a small service.

Containerize it.

Push it to Azure Container Registry.

Deploy it to Azure Container Apps.

Celebrate the win — visibly. Momentum is a leadership tool.

Training & Community

• Microsoft Learn: Introduction to Containers

• CNCF Chapters for practical, community-driven learning

⸻

Walk — Operationalize and Widen the Circle

This is where Kubernetes enters the picture — but don’t overcomplicate it. Let AKS manage the control plane and focus your energy on application consistency, not infrastructure plumbing.

Key priorities at this stage:

• Define OCI-compliant image standards

• Enforce runtime guardrails (RBAC, resource limits, network policies)

• Document a “golden path” for developers

Bring suppliers and partners along — using a story they already lived

During our cloud VM transformation, we faced the exact same resistance we see with containers today.

Teams weren’t sure what needed to change.

Suppliers insisted their software only ran on “physical servers.”

Partners sent dependency matrices longer than some design docs.

Security wanted clarity before greenlighting anything.

Everyone hesitated — waiting for someone else to take the first step.

And yet, everything shifted with one simple realization:

The workload didn’t change — the hosting model did.

When people understood that:

• The OS was still the OS

• Security controls still applied

• Support contracts didn’t break

• Applications didn’t need rewriting

…fear evaporated. Confidence grew. Adoption took off.

Containers follow this story almost perfectly.

We package differently,

we run more consistently,

we operate at higher velocity,

but the core workload logic stays the same.

When teams and suppliers understand this, adoption accelerates.

For containers today:

• Artifact: OCI image

• Runtime: Kubernetes API

• Hosting: AKS

Providing clear onboarding kits makes this transition even smoother.

Certifications to Build Confidence

• KCNA

• CKA

• CKAD

⸻

Run — Scale, Govern, and Modernize

Now you’re not just running Kubernetes — you’re treating AKS as a product.

Focus on:

• Multiple node pools

• Autoscaling

• Policy-as-code

• Observability

• Cost transparency

• Integrated identity (Entra ID)

• Deep diagnostics (Azure Monitor)

Modernization becomes strategic:

• Replatform for quick wins

• Refactor when the ROI is clear

• Rearchitect when agility demands it

Start with Linux-based images — the ecosystem (and AKS itself) assumes Linux first.

⸻

Why Leaders Love This Approach

• Speed: Faster releases, fewer deployment surprises

• Resilience: Self-healing workloads, managed upgrades

• Portability: OCI standards eliminate lock-in fears

• Partner alignment: A shared, standardized operating model

KPIs That Actually Matter

• Lead time for changes → Target 30–50% improvement

• Change failure rate → Reduced through progressive delivery

• Cost visibility → Per service, per node pool, per pod

⸻

Next Steps

1. Start with one pilot service.

2. Align teams and suppliers to OCI standards.

3. Upskill with Microsoft Learn and CNCF certifications.

4. Join your local CNCF chapter — community accelerates everything.

⸻

Quick Links

• Microsoft Learn: Containers & AKS

• OCI Specifications

• CNCF Community

• Certifications: KCNA, CKA, CKAD

Author

Kevin Evans - Cloud Native Leader