Learn Docker in a Month of Lunches • Elton Stoneman & Bret Fisher • GOTO 2026

In a conversation with fellow Docker educator Bret Fisher, Elton Stoneman discusses the newly released second edition of his book, “Learn Docker in a Month of Lunches,” reflecting on the evolution of the container ecosystem and the enduring importance of its foundational principles.

The Enduring Relevance of Docker

A decade after its inception, Docker remains the industry standard for packaging, deploying, and updating software. Its core value proposition—separating application dependencies from the host operating system—solves the persistent problem of environmental inconsistency. Before containers, developers and operators wrestled with “runbooks and manual installation steps,” where a minor OS update could break an application due to conflicting dependencies like a specific Python version.

Containers provide a transformative solution by packaging an application and all its dependencies into a single, portable artifact. This ensures that an application runs identically everywhere, from a developer’s laptop to production servers. This fundamental concept has not been superseded; it remains the most effective model for application delivery.

Ecosystem Evolution: What’s Changed in 5 Years?

While the core principles are the same, the container landscape has matured significantly, driven by portability and ubiquity.

• Multi-Platform Images: The concept of “build once, run anywhere” has become more robust. Initially, Docker was forward-thinking in its support for different CPU architectures like ARM, which seemed niche at the time. Today, with ARM processors being offered by major cloud providers like AWS for significant cost savings and Apple’s transition to ARM for its entire Mac lineup, this capability is essential. A multi-platform image acts as an umbrella manifest, pointing to different image builds for various combinations of operating systems (e.g., Linux, Windows) and CPU architectures (e.g., Intel, ARM). The container runtime automatically pulls the correct version, making the process seamless for the end-user. The developer simply needs to build their Dockerfile for multiple target architectures.
• Docker Compose: Docker Compose has evolved from docker-compose (with a hyphen) to a native CLI plugin, docker compose. It remains a critical tool for defining and running multi-service applications locally. It serves as an excellent development environment and a stepping stone to production orchestrators like Kubernetes. Compose is also a powerful build tool, allowing developers to build and push all components of a distributed application with a single command.
• Cloud Platforms: The proliferation of managed container platforms (e.g., Google Cloud Run, Azure Container Apps) allows developers to run containers with minimal operational overhead, often directly from a Docker image, further cementing Docker’s role as the universal packaging standard.

Bridging the Gap: From Docker Beginner to Expert

Many developers today learn Docker superficially, picking up just enough to use a pre-existing Dockerfile or compose.yaml on a project. This creates a knowledge gap where fundamental concepts are missed. The difference between a beginner and an expert lies in understanding the “why” and “how” behind the commands.

Key areas that distinguish an expert include:

• Image Optimization: Understanding how to structure a Dockerfile to leverage the build cache effectively, resulting in faster builds. This also includes techniques for creating small, efficient images, which is crucial for reducing storage costs and deployment times. A common anti-pattern, especially with vendor-supplied images, is shipping bloated images that are gigabytes in size because they include an entire OS or unnecessary build tools.
• Security: The structured, layered nature of Docker images enables powerful security scanning. Tools like Trivy can inspect an image’s contents and identify components with known vulnerabilities (CVEs), providing a clear path to remediation by specifying which versions to update to.
• Configuration Management: A core principle, aligned with the 12-Factor App methodology, is to build a single, immutable image artifact that can be promoted across all environments (development, testing, production). Configuration, which varies between environments (e.g., database connection strings, API keys), should be injected at runtime. Hard-coding configuration into an image is a common mistake that leads to a proliferation of unnecessary image builds and reduces portability.
• Multi-Platform Builds: Truly understanding how BuildKit, Docker’s modern build engine, can create multi-platform images in parallel, and knowing how the underlying image manifests link everything together.

“I’ve been using Kubernetes for 6 months and I had never actually made my own image because they’re all made already… I am learning the Docker fundamentals now even though I’ve been operating Kubernetes for so long.”

This phenomenon highlights a growing trend where engineers jump into orchestration without grasping the fundamentals of the container images they are deploying. This is akin to driving a car without any knowledge of how the engine works; when it breaks down, you are unable to diagnose or fix it.

The Future is Containerized

The skills learned with Docker and containers are foundational and have a long runway. New paradigms like Serverless and AI are built on top of containers. As Elton states, “whatever comes next, there’s so much that is built to run on Kubernetes, whatever comes next, it’s going to have to support the Kubernetes API.” This means that Docker images and Kubernetes manifests will remain relevant for the foreseeable future, making a deep understanding of these technologies a durable career investment.

• Tags:
• Devops
• Feature
• Kubernetes
• Cloud Native
• Docker
• Containers
• Docker Compose