From "It Works on My Machine" to Docker
DevOps & Docker Workshop — Session 1
From “It Works on My Machine” to Docker
A story-driven, architectural journey through modern software engineering.
Meet Lehar Loom.
A fast-growing Indian ethnic-wear brand that just wants a website that works.
Lehar Loom Pvt Ltd
Fastest growing ethnic clothing retailer online. Handcrafted kurtas, sarees, and festive wear shipped across India.
Meet Sam.
Senior Developer. Coffee enthusiast. Believed by everyone to possess infinite computing knowledge.
Sam
Senior Software Developer & Reluctant SysAdmin
One application. One server.
Physical hardware humming under the office desk. Pure architectural simplicity.
Physical Office Server
Dual Xeon • 64GB RAM • Humming quietly near the water cooler
Sam builds it. Sam deploys it. Sam fixes it.
When you are the developer, the sysadmin, and the midnight customer hotline.
1. Developer
Writes product features, creates responsive layouts, builds shopping cart logic.
2. SysAdmin
Configures Nginx reverse proxies, creates systemd daemons, manages SSL certificates.
3. Support
Receives emergency calls when payment gateways fail at midnight on Diwali sales.
And it works! 🎉
Orders are flowing, customers are shopping, and CPU temperature is holding at 42°C.
Then Lehar Loom gets ambitious.
Success breeds roadmaps. Roadmaps breed unexpected horizontal expansion.
Ethnic Wear
Lehar Loom
Candles
Lehar Candles
Decor
Lehar Living
More Brands...
Scale Challenge
Welcome, Lehar Candles.
Two distinct e-commerce brands under one corporate roof.
Lehar Loom
Ethnic wear portal built on Node 20. High traffic, heavy image caching.
Lehar Candles
Luxury aromatherapy website acquired from an agency, running on Node 18.
Sam builds another website.
Both Lehar Loom and Lehar Candles deployed onto the same physical office server.
They need different dependencies.
Loom needs Node 20 with Package X v2. Candles requires Node 18 with Package X v1.
Requirements A
- • Node.js: v20.10 LTS
- • Package X: v2.4.0 (Modern)
- • OpenSSL: 3.0
Requirements B
- • Node.js: v18.12 Legacy
- • Package X: v1.0.8 (Deprecated)
- • OpenSSL: 1.1.1
And now... things get interesting.
Two applications pulling the same global library in opposite directions.
The Shared Global Package Dilemma
Lehar Loom
Needs: Node 20 + Package X v2
One server filesystem cannot satisfy both versions simultaneously.
Lehar Candles
Needs: Node 18 + Package X v1
"If I upgrade this... what breaks?"
The existential dread of running npm update in production.
So Sam isolates the applications.
Enter the Hypervisor: carving one physical box into discrete virtual machines.
Now each application gets its own environment.
VM 1 runs Linux + Node 20. VM 2 runs Linux + Node 18. Zero interference.
Linux Ubuntu 22
Linux Debian 11
But there is a catch.
Every single VM demands its own full Guest Operating System kernel, drivers, and gigabytes of memory.
Virtual Machines vs. Docker Containers
Virtual Machines
HeavyweightEach VM virtualizes full physical hardware and runs an entire Guest OS.
Docker Containers
LightweightContainers share the host OS kernel via Linux namespaces & cgroups.
Then Lehar launches 10 more applications.
10 applications = 10 full guest operating systems chewing through RAM.
Sam hires more developers.
Priya, Rahul, Anita join the engineering ranks to accelerate feature delivery.
Sam
Senior Dev (MacBook)
Priya
Frontend Dev (MacBook)
Rahul
Backend Dev (Ubuntu)
Anita
QA Engineer (Windows)
Priya runs the application.
Fresh git clone, clean terminal, standard npm install.
💥 It doesn't work.
Missing native C++ bindings, mismatched Node version, corrupted global lockfile.
Node-Gyp Bindings Failed
Error: Cannot find module './build/Release/canvas.node'. Missing Xcode tools, Cairo headers, and Python 3.9 path.
"It works on my machine."
The most notorious five-word sentence in the history of software development.
“It works on my machine.”
The application isn't just the source code.
Software is an iceberg: Code + Runtime + System Libs + Env Variables + OS Config.
"What if we package all of this together?"
Bundle the code, the runtime, the libraries, and the exact dependencies into a sealed unit.
Package the Entire Execution Envelope
Don't just send code over git. Send the code, the exact runtime, pre-built binaries, and configuration packed in a sealed box.
Containers.
Isolated process user-spaces sharing a single host operating system kernel.
Docker.
Build once. Ship anywhere. Run consistently.
DOCKER
An image is the package.
An immutable blueprint containing application code, runtime, libraries, and files.
A container is a running instance of that image.
Spin up one, two, or twenty identical running processes from a single immutable image.
Now imagine 100 containers.
Microservices boom: Frontend, Backend, Redis, Postgres, Auth, Payment Workers...
"Who is going to manage all of these?"
Tracking container health, port mappings, failover, and IP addresses by hand.
Managing Fleets by Hand is Impossible
How do containers discover each other? What handles load balancing? What restarts dead services at 3 AM?
Kubernetes.
Docker helps run containers. Kubernetes helps manage them at scale.
KUBERNETES
Docker helps run containers. Kubernetes helps manage them across thousands of servers.
"Keep my containers running."
Declarative desired state + automatic self-healing restart loops.
Interactive Self-Healing Pod Simulation
👉 Click any pod below to crash it. Watch K8s auto-reconcile and revive a new healthy container!
The company is releasing code every day.
Feature Monday, hotfix Tuesday, promo Wednesday, rollback Thursday, bugfix Friday.
Checkout Feature
Diwali Promo
Candles Upsell
Gateway Fix
“Small Change” 💀
Someone has to build, test, and deploy all of this.
Manual testing, manual ssh into servers, manual Docker build commands.
CI/CD.
Automate the journey from git push to live production.
Automated CI/CD Delivery Pipeline
1. Git Push
Merged to main
2. Build
Compile assets
3. Test Suite
248 tests pass
4. Docker Build
Package image
5. Deploy
Rollout to Prod
CI = Automatically build and test changes.
Every pull request triggers an automated test runner. Catch bugs before humans ever merge.
CD = Automatically deliver changes.
Approved commits build into Docker images and deploy to staging and production without manual SSH.
GitHub Actions.
One powerful way to implement CI/CD directly within your code repository.
on: [push]
jobs:
build-and-deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- run: docker build -t lehar/app:latest .
- run: kubectl set image deployment/web web=lehar/app:latestNow the infrastructure is getting complicated.
VPCs, Subnets, EC2, Load Balancers, RDS Databases, S3 Buckets, Security Groups.
VPC & Subnets
EC2 & EKS
Load Balancer
RDS Postgres
"Sam, recreate production."
Clicking through hundreds of wizard dropdowns in the AWS/GCP web console.
“Sam, recreate production in Mumbai.”
Can anyone remember all 142 checkboxes, port allowances, and security groups configured over the last two years?
Terraform.
Infrastructure as Code (IaC).
TERRAFORM
Don't click cloud resources. Write them in declarative code and version control them.
Instead of clicking infrastructure into existence...
Write declarative configuration files and let Terraform provision the cloud automatically.
ClickOps Nightmare vs. Declarative Code
Web Console Memory Test
Clicking 142 checkboxes, dropdowns, and subnets across 8 different web console tabs.
Declarative Blueprint
Define the desired state once in code. Terraform builds the entire fleet in seconds.
resource "aws_vpc" "lehar_vpc" {
cidr_block = "10.0.0.0/16"
}
resource "aws_eks_cluster" "cluster" {
name = "lehar-production"
role_arn = aws_iam_role.eks.arn
version = "1.30"
}Now connect the pieces.
The unified DevOps Architecture: Containers, Automation, and Infrastructure as Code.
Code → Container → Deployment → Infrastructure
The complete journey of modern software from developer keystroke to global cloud.
DevOps is the bigger picture.
A continuous feedback loop: Plan, Code, Build, Test, Release, Deploy, Operate, Monitor.
The DevOps Infinity Feedback Loop
Compile code & build immutable Docker images
One-Line Definitions.
Clear mental models for the four pillars of modern cloud architecture.
Docker
Package & run applications consistently.
Kubernetes
Manage & scale container fleets.
CI / CD
Automate testing and releases.
Terraform
Infrastructure as Code.
GitHub Actions is the automation engine.
The glue connecting code changes directly to container builds and cluster deployments.
DevOps ≠ Docker
Docker is one vital foundational piece of the larger DevOps ecosystem.
DevOps ≠ Docker
DevOps is the entire manufacturing factory and engineering culture. Docker is the standardized shipping container that makes modern factories possible.
We Zoom In.
From the high-altitude cloud map down to the core engine of containerization.
We Zoom In.
Now that you understand the entire DevOps map, the rest of this workshop is dedicated to mastering containerization with Docker.
Today's Focus: DOCKER
Images, Containers, Dockerfiles, Networking, Volumes, and Docker Compose.
Images
Containers
Dockerfile
Networking
Volumes
Compose
What exactly happens when I run:
docker run -d -p 80:80 nginx
Welcome to Docker. Let's build something.
No more 'works on my machine'. Time to get hands-on in the terminal.
Welcome to Docker. Let's build something.
No more “works on my machine”. Time to open your code editors and terminals for hands-on Docker exercises!