DEV Community: E-Learning Sherdil

AWS vs Azure vs GCP (2026): Which Cloud Certification Should You Get First?

E-Learning Sherdil — Sat, 06 Jun 2026 11:19:07 +0000

📌 This article was originally published on Sherdil E-Learning. I'm republishing it here so the dev.to community can benefit too.

Choosing between AWS, Azure, and Google Cloud is the biggest decision every aspiring cloud professional makes. The wrong choice costs months of study time and puts you in a smaller job market. The right one accelerates your career.

This guide compares the three platforms on what actually matters in 2026 — market share, job volume, certification cost and difficulty, freelance demand, and the kind of work you'll actually do once hired. It's written for fresh graduates, working professionals planning a switch, and freelancers selling cloud services internationally.

At-a-glance comparison

	AWS	Azure	GCP
Global market share (Q4 2025)	31%	25%	11%
Entry-level cert	Cloud Practitioner (CLF-C02)	AZ-900 Fundamentals	Cloud Digital Leader
Entry cert cost (USD)	~$100	~$99	~$99
Associate-level cert	Solutions Architect Associate	AZ-104 Administrator	Associate Cloud Engineer
Best for	Maximum job options, freelance	Corporate / enterprise / gov	Data, ML, premium freelance
Difficulty of first exam	Beginner-friendly	Easiest	Slightly harder
Freelance rate (Upwork, 2026)	$25–$50/hr	$25–$45/hr	$35–$70/hr (scarcity)

AWS: the safest first pick for most candidates

AWS holds 31% of the global cloud infrastructure market as of Q4 2025 (Synergy Research). That scale shows up directly in job listings — AWS-specific roles outnumber Azure roles roughly 2:1 and GCP roles roughly 5:1 in active 2026 postings. Most multinational employers, software houses, and freelance clients on Upwork default to AWS, so an AWS certification opens the widest range of doors.

The recommended path for beginners is the AWS Certified Cloud Practitioner (CLF-C02) — around $100 USD, foundational coverage of AWS services, pricing, and the shared responsibility model. The next step is the AWS Solutions Architect Associate (SAA-C03), one of the most globally recognised cloud certifications and a common credential for remote international roles.

For a structured path, the Sherdil AWS 3-in-1 Training Bundle covers Cloud Practitioner, Solutions Architect Associate, and SysOps Administrator together.

Azure: the enterprise and government choice

Azure is the cloud of choice for organisations that already run Microsoft software — banks, telecoms, large government departments, and any multinational standardised on Microsoft 365 and Active Directory. If you want a stable corporate-sector role rather than freelance or startup work, Azure is often the stronger pick.

The entry point is the AZ-900 Azure Fundamentals exam — widely considered the easiest cloud certification on the market. After AZ-900, AZ-104 (Azure Administrator Associate) is the credential that employers actually filter resumes by. For security-focused roles, AZ-500 is the natural follow-up.

GCP: the data, AI, and premium-freelance specialist

Google Cloud is the smallest of the three by market share (11% globally, Synergy Research Q4 2025) but it punches above its weight in two areas: data engineering with BigQuery, and ML workloads via Vertex AI.

GCP-certified professionals are rare, which keeps competition low and freelance rates high — typically 20–40% above the AWS equivalent on Upwork for data and ML work.

The two entry points are Cloud Digital Leader (non-technical, conceptual) and Associate Cloud Engineer (hands-on, better if you already have IT background). The Professional Cloud Architect certification, once you're ready, is consistently ranked among the highest-paying IT certifications globally.

Freelance rate snapshot (Upwork, 2026)

For certified engineers competing on Upwork in 2026:

Platform	Typical hourly range (USD)
AWS	$25–$50/hr
Azure	$25–$45/hr
GCP (data + ML)	$35–$70/hr

GCP's scarcity premium is real — fewer certified professionals in the market means consistently higher rates for the engineers who hold the credential.

Which one should you pick first?

Want maximum job options + international freelance? → Start with AWS. Largest job volume, biggest Upwork market, broadest tooling ecosystem. Cloud Practitioner is a gentle first exam.

Want corporate-sector / enterprise / government work? → Start with Azure. AZ-900 is the easiest cloud certification to pass. AZ-104 opens the most interview doors at the next level. Especially strong if your target employer already runs Microsoft 365.

Interested in data engineering, ML, or Kubernetes-heavy DevOps? → Start with GCP. Fewer GCP-certified candidates means highest remote-work premium. Google Cloud has stronger native tooling for data and ML workloads.

No strong preference? → AWS is the lower-risk pick. Most likely to lead to a first job. Concepts transfer cleanly to Azure and GCP if you expand later.

The multicloud advantage

The best mid-career strategy in 2026 is not to stop at one certification. Companies increasingly run two or even all three major clouds simultaneously to avoid vendor lock-in and to use the best service from each.

Engineers fluent in multiple clouds earn 20–40% more than single-cloud specialists at the senior level (Stack Overflow Developer Survey 2025).

The Sherdil Cloud Pro Starter Pack covers AWS, Azure, and GCP foundations in a single track for candidates who want all three options open from the start.

Frequently asked questions

Which cloud certification is easiest to pass?

AZ-900 Azure Fundamentals is widely accepted as the easiest. AWS Cloud Practitioner is also beginner-friendly. Both can be passed in four to eight weeks of part-time study with no prior IT background. GCP certifications tend to require a bit more technical fluency upfront.

How long does it take to get certified?

With one to two hours of daily study, most beginners pass a foundational certification in four to eight weeks. Associate-level certifications (Solutions Architect Associate, AZ-104, Associate Cloud Engineer) typically need three to six months including hands-on lab practice.

How much do these certifications cost?

Certification	Cost (USD)
AWS Cloud Practitioner	~$100
AWS Solutions Architect Associate	~$150
AZ-900	~$99
AZ-104	~$165
GCP Cloud Digital Leader	~$99
GCP Associate Cloud Engineer	~$125

All three vendors run periodic discounts and free certification vouchers through their training programmes — worth checking before booking.

Can I get a cloud job without a degree?

Yes. Cloud certifications are industry credentials that most employers value as much as or more than a traditional degree, particularly for first or second jobs. A strong GitHub portfolio with two or three deployed projects (a static site on S3, a small API on EC2 behind a load balancer, an Azure Functions workflow) plus one certification is the minimum-viable application package for entry-level cloud roles.

Will AI tools replace cloud engineers?

AI assistants speed up specific tasks — writing Terraform, generating IAM policies, debugging CloudWatch logs — but cloud-engineering job postings have grown, not shrunk, in 2025 and 2026. The shift is towards engineers who use AI tools effectively rather than away from the role itself.

Can I work remotely for international companies?

Yes — and this is one of the highest-leverage paths available. Cloud engineers with an AWS or GCP certification regularly land remote roles paying in USD or EUR. Usual requirements: strong written English, a verifiable GitHub portfolio, an Upwork or LinkedIn profile with at least two completed client projects, and at least four working hours of overlap with Europe or US East Coast.

Is it worth getting certified in 2026?

Demand for certified cloud professionals continues to outpace supply globally — Gartner forecasts the global cloud services market to reach roughly $1.3 trillion by 2027. A first cloud certification in 2026 is one of the highest-return training investments available to IT professionals.

Next steps

The right cloud certification for you is the one that matches the work you actually want to do — not the one with the largest market share or the highest theoretical salary. Use the decision framework above, pick one, and start.

For a structured deep-dive, the AWS, Azure & GCP 3-in-1 Training Bundle is the most common starting point at Sherdil. For candidates who want all three platforms covered, the Cloud Pro Starter Pack covers AWS, Azure, and GCP foundations in one track.

About the author

Muhammad Usman Khan is a Lead Cloud Instructor at Sherdil E-Learning, holding the Alibaba Cloud ACP certification along with AWS and Azure credentials. He is an expert trainer in AWS and Google Cloud, having delivered 1,500+ hours of training across 12+ countries and completed 50+ multi-cloud projects.

💬 Found this useful? Drop a ❤️ or a 🦄, and let me know in the comments which path you chose — AWS for breadth, Azure for enterprise, or GCP for the data/ML premium?

📖 Full original article (with PKR salary tables and Pakistan-specific market data): elearning.sherdil.org/pages/aws-vs-azure-vs-gcp-certification

Docker for Beginners (2026): From Zero to Your First Dockerfile

E-Learning Sherdil — Fri, 05 Jun 2026 14:49:05 +0000

📌 This article was originally published on Sherdil E-Learning. I'm republishing it here so the dev.to community can benefit too.

If you're a developer or IT professional looking for a practical Docker tutorial, this guide walks you through everything you need to go from zero containers to a working Dockerfile. Docker has changed how modern applications are built, shipped, and deployed — it's now a baseline skill for almost every DevOps and backend role.

This guide covers what Docker is, why it matters for your career, how to install it on Windows, Ubuntu, and macOS, the core concepts you need to know, hands-on commands you can run today, your first Dockerfile, and where Docker fits in the modern DevOps stack.

What is Docker?

You build a web application on your laptop. It runs fine. Your teammate pulls the code on their machine and it crashes. The reason is almost always environment differences — different Node versions, missing system libraries, a Python module installed globally on your machine but not theirs.

Docker solves this by packaging your application along with everything it needs — code, runtime, system tools, libraries, and settings — into a single isolated unit called a container. The container runs identically on any machine that has Docker installed: your laptop, a teammate's laptop, a CI runner, a production server, or a cloud platform.

The shorter version: a virtual machine ships a whole operating system per application; Docker ships just the application and its dependencies, with the host operating system shared underneath. That difference makes containers start in seconds rather than minutes and weigh megabytes rather than gigabytes.

Why Docker is a high-return skill in 2026

Four practical reasons Docker pays off fast:

Near-default requirement in DevOps and backend job listings. Reviewing Q1 2026 listings, roughly two-thirds of DevOps roles and over half of backend developer roles list Docker as a required or preferred skill — many ATS pipelines filter resumes by it.
High freelance rates. Containerising legacy applications, setting up CI/CD pipelines, and refactoring monoliths into microservices are typical Upwork projects paying $25 to $60 per hour for engineers who can deliver a working Docker bundle.
Prerequisite for the major cloud platforms. AWS ECS, Azure Container Instances, and Google Cloud Run all run Docker containers under the hood, so any production cloud work eventually requires Docker fluency.
You cannot meaningfully learn Kubernetes without Docker first. Kubernetes orchestrates Docker containers. Every cluster you deploy on is running images you built and pushed to a registry. Docker is step one of the modern DevOps career path.

Docker vs virtual machines

	Virtual Machine	Docker Container
What ships	Full guest OS + app	App + dependencies only
OS overhead	One full OS per VM	Shared host OS kernel
Startup time	Minutes	Seconds
Size	Gigabytes	Megabytes
Density	~10–20 per host	Hundreds per host
Use case	Isolating whole OSes / kernels	Isolating applications

Core Docker concepts you need to know

Five terms come up constantly in Docker work. Get comfortable with these and the rest of the ecosystem makes sense.

Docker image

A read-only template that contains everything needed to run an application: the code, runtime, libraries, environment variables, and configuration files. Images are built from instructions in a Dockerfile and stored on your machine or in a registry like Docker Hub.

Docker container

A running instance of an image. When you run an image, Docker creates a container from it. You can start, stop, restart, and delete containers without affecting the underlying image. Multiple containers can run from the same image.

Dockerfile

A plain text file with step-by-step instructions for building an image. It specifies the base image (for example Ubuntu or Node.js), the commands to install dependencies, the files to copy in, and the command to run when the container starts.

Docker Hub

The largest public registry of Docker images. It hosts official images for Node.js, Python, MySQL, Nginx, Redis, and almost every other common piece of infrastructure. You pull these as base images and build on top of them.

Docker Compose

A tool for defining and running multi-container applications. Instead of running each container manually, you create a docker-compose.yml file that defines all the containers (web server, database, cache, etc.), their relationships, and their networks. One command — docker compose up — starts everything.

Installing Docker, step by step

Windows

Download Docker Desktop from docker.com/products/docker-desktop. Run the installer and enable WSL 2 when prompted. Restart your computer, then open Command Prompt or PowerShell and check the install:

docker --version

You should see Docker version 28 or newer. If you see a version number, Docker is installed correctly.

Ubuntu (official Docker apt repository)

The Ubuntu-packaged docker.io is often a major version behind. Install from the official repository instead:

sudo apt-get update
sudo apt-get install -y ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
    -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] \
    https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo \"$VERSION_CODENAME\") stable" | \
    sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io \
    docker-buildx-plugin docker-compose-plugin

sudo systemctl enable --now docker
docker --version

For full reference and other Linux distributions, see the official Docker Engine install guide.

macOS

Download Docker Desktop for Mac from docker.com and drag it into Applications. Open Docker Desktop, grant the required permissions, and confirm with docker --version. On Apple Silicon Macs, Docker Desktop runs natively on ARM64.

Your first Docker container: hands-on tutorial

Open a terminal and run your first container:

docker run hello-world

Docker pulls the hello-world image from Docker Hub and runs it. You'll see a message confirming the install is working.

Now run something more useful — an Nginx web server:

docker run -d -p 8080:80 --name my-web-server nginx

Breaking down the flags:

-d → run the container in the background (detached mode)
-p 8080:80 → map port 8080 on your machine to port 80 inside the container
--name → give the container a readable name
nginx → the image to run

Open http://localhost:8080 in a browser and you should see the Nginx welcome page.

Useful follow-up commands:

# list running containers
docker ps

# stop the container
docker stop my-web-server

# remove the container
docker rm my-web-server

Writing your first Dockerfile

Let's containerise a simple Node.js application. In a new directory, create a file named Dockerfile (no extension) with this content:

FROM node:22-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "app.js"]

Reading the Dockerfile line by line:

FROM node:22-alpine → start from the official Node.js 22 image, Alpine variant for small size
WORKDIR /app → set the working directory inside the container to /app
COPY package*.json ./ → copy package.json and package-lock.json first (this enables layer caching for faster rebuilds)
RUN npm install → install dependencies inside the container
COPY . . → copy the rest of the application source
EXPOSE 3000 → declare the port the container listens on
CMD ["node", "app.js"] → the command Docker runs when the container starts

Build and run the image:

docker build -t my-node-app .
docker run -d -p 3000:3000 --name my-app my-node-app

Full reference: Dockerfile reference on docs.docker.com.

Docker in the real world: how modern teams use it

Four of the most common production patterns you'll encounter:

Multi-service web apps. For e-commerce, SaaS, or marketplace applications, teams run separate containers for the web frontend, the API backend, the database, and the cache layer (Redis). Docker Compose wires them together, and the same compose file works for local development, staging, and production with only environment-variable changes.

Freelance & client deliveries. Delivering work as a Dockerised package — a docker-compose.yml plus a README — means a client runs one command (docker compose up) and has your entire application working locally. This is a major differentiator on Upwork; engineers regularly win contracts specifically because their deliverable is a one-command Docker bundle rather than a tarball with a setup README.

Environment parity. Software teams use Docker to keep development, testing, and production environments identical — which removes a large category of "works on my machine" bugs from the QA cycle.

Cloud deployments. AWS ECS, Azure Container Instances, and Google Cloud Run all accept Docker images directly. The image you build locally is the same image you push to production. No "rebuild for prod" step, no environment drift.

To deploy Docker containers on AWS, the Sherdil AWS 3-in-1 Training Bundle covers ECS deployment alongside Cloud Practitioner and Solutions Architect content.

Docker commands cheat sheet

The commands you'll use almost daily once you start building images:

Command	What it does
`docker run <image>`	Create and start a new container from an image
`docker ps`	List running containers
`docker ps -a`	List all containers (including stopped)
`docker stop <name>`	Stop a running container
`docker start <name>`	Start a stopped container
`docker rm <name>`	Remove a container
`docker images`	List local images
`docker rmi <image>`	Remove a local image
`docker pull <image>`	Download an image from Docker Hub
`docker push <image>`	Upload an image to a registry
`docker build -t <name> .`	Build an image from the Dockerfile in current directory
`docker logs <name>`	View logs from a container
`docker exec -it <name> sh`	Open a shell inside a running container
`docker compose up`	Start everything in `docker-compose.yml`
`docker compose down`	Stop and remove everything from compose
`docker system prune`	Clean up unused images, containers, and networks

Full command reference: Docker CLI reference.

Frequently asked questions

Is Docker free to use?

Docker Engine is open-source and completely free. Docker Desktop is free for personal use, education, and small businesses (under 250 employees and under $10M annual revenue). Larger commercial use requires a paid Docker subscription.

Can I learn Docker without knowing Linux?

Basic Linux command-line familiarity is strongly advised. Most containers run Linux internally, and Docker commands are executed in a terminal. You don't need to be a Linux expert — comfort with cd, ls, mkdir, cat, grep, and a text editor like nano or vim is enough to start.

How long does it take to learn Docker?

The basics (images, containers, Dockerfiles, Docker Compose) take two to three weeks with daily practice. Becoming proficient enough for a junior DevOps role typically takes two to three months including hands-on projects.

Should I learn Docker or Kubernetes first?

Always Docker first. Kubernetes orchestrates Docker containers, so you need to understand containers before you can orchestrate them. A reasonable progression: one to two months on Docker, then four to six weeks on Kubernetes.

What is the difference between `docker run` and `docker compose up`?

docker run starts a single container. docker compose up starts everything defined in a docker-compose.yml — typically multiple containers (web, API, database, cache) wired together with networks and shared volumes. Use docker run for quick tests and individual services; use Compose for any real application.

Can I use Docker on Windows without WSL 2?

Modern Docker Desktop on Windows requires WSL 2 (or Hyper-V) for its backend. WSL 2 is the recommended setup and works out of the box on Windows 10 (build 19041+) and Windows 11. There is no production-grade native Windows containers experience aimed at typical developer workloads.

Next steps: from Docker to a DevOps career

Docker is the first major skill on the DevOps roadmap. After you're comfortable building and running containers, the natural progression is:

Kubernetes — container orchestration
Terraform — infrastructure as code
One cloud platform — AWS is the most common starting point

For a structured deep-dive, the Docker Tutorial for Beginners (Pakistan) at Sherdil E-Learning covers Docker in depth, then takes you through Kubernetes, CI/CD, AWS, and Terraform.

About the author

💬 Found this useful? Drop a ❤️ or a 🦄, and let me know in the comments what you'd like the next deep-dive to cover — Docker Compose for multi-service apps, image optimization, or moving from Docker to Kubernetes?

📖 Full original article (with diagrams + screenshots): elearning.sherdil.org/pages/docker-tutorial-pakistan-beginners

Kubernetes vs Docker (2026): What's the Difference and Which Should You Learn First?

E-Learning Sherdil — Thu, 04 Jun 2026 12:40:02 +0000

📌 This article was originally published on Sherdil E-Learning. I'm republishing it here so the dev.to community can benefit too.

The Kubernetes vs Docker question is one of the most common sources of confusion for developers entering DevOps. People hear both names constantly, see them used together in job listings, and assume they must be competitors.

They are not. Docker and Kubernetes do different jobs, and most modern infrastructure uses both.

This guide explains what each tool actually does, how they fit together in a real deployment, the practical difference between Docker Compose and Kubernetes, and which one you should learn first.

Docker: the container creator

Docker is a tool for building, running, and managing containers. A container is a lightweight, portable package that contains an application together with its dependencies, runtime, system libraries, environment variables, and configuration files. The same container runs the same way on a laptop, a CI runner, a production server, or a cloud platform.

In a typical Docker workflow you:

Write a Dockerfile that describes how to build the image
Run docker build to produce the image
Run docker run to launch a container from it

For multiple containers (a web app plus a database, for example), you use Docker Compose to define the whole set in a docker-compose.yml file and start them with one command.

Docker is excellent for individual containers and small multi-container applications. The limitation is scale. What happens when you need a hundred containers across a dozen servers? When one container crashes at 3 a.m.? When you need to roll out a new version without downtime? Docker alone does not solve those problems.

For the official reference, see docs.docker.com.

Kubernetes: the orchestration layer above Docker

Kubernetes (often shortened to K8s) is an open-source platform that runs containers across many machines as a single coordinated system. It was originally built at Google, based on their internal Borg cluster manager, and is now governed by the Cloud Native Computing Foundation (CNCF).

Kubernetes does not create containers — Docker (or another container runtime) does that. What Kubernetes does is:

Decide where each container should run across a cluster of machines
Restart containers when they crash
Scale them up or down based on traffic
Manage networking between them
Roll out new versions with zero downtime
Route requests to healthy instances

According to the CNCF Annual Survey 2024, 84% of organisations are now using or evaluating Kubernetes in production, making it the de facto standard for running containerised workloads at scale.

Reference: kubernetes.io official Concepts documentation.

Side-by-side comparison

	Docker	Kubernetes
Primary job	Build, run, and package containers	Orchestrate containers across a cluster
Scope	Single host (mostly)	Multi-host cluster
What it manages	Images, containers, volumes, networks	Pods, deployments, services, nodes
Configuration language	Dockerfile, `docker-compose.yml`	YAML manifests (kubectl)
Self-healing	No (manual restart)	Yes (automatic)
Auto-scaling	No	Yes (built-in HPA)
Zero-downtime deploys	Not natively	Yes (rolling updates)
Learning curve	2–3 weeks to basics	2–3 months to basics
When to use	Local dev, simple apps, CI	Production at scale, microservices

Docker is one tool. Kubernetes is a system. They are at different layers of the same stack.

How Docker and Kubernetes work together in a real deployment

The clearest way to see how the two tools fit together is to walk through a real deployment pipeline:

Write your application code (Node.js, Python, Java, etc.)
Create a Dockerfile that packages the application into a Docker image
Build the image with docker build and push it to a container registry (Docker Hub, AWS ECR, Google Artifact Registry)
Write Kubernetes manifests — YAML files declaring how many copies of the container to run, how much CPU and memory each needs, which ports to expose, and how they connect to each other
Apply the manifests to your cluster with kubectl apply. Kubernetes pulls the Docker image from the registry and runs the specified number of containers (called pods)
Kubernetes continuously monitors those pods. If one crashes, Kubernetes restarts it. If traffic increases, it scales up automatically. If you push a new image version, it performs a rolling update with zero downtime.

In short: Docker builds and runs the container; Kubernetes decides where it runs, keeps it healthy, and scales it. Complementary, not competing.

What a Kubernetes manifest actually looks like

A minimal Kubernetes Deployment manifest for a Node.js application running three replicas of a Docker image:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-node-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-node-app
  template:
    metadata:
      labels:
        app: my-node-app
    spec:
      containers:
        - name: my-node-app
          image: my-registry/my-node-app:1.0.0
          ports:
            - containerPort: 3000
          resources:
            requests: { cpu: "100m", memory: "128Mi" }
            limits:   { cpu: "500m", memory: "256Mi" }

This single file tells Kubernetes:

Pull this Docker image
Run three copies of it
Give each one between 100 and 500 millicores of CPU and between 128 and 256 MB of memory
Expose port 3000
Keep all three running. If one crashes, restart it. If a node goes down, reschedule its pods on another node.

That's about 20 lines of YAML for a production-grade, self-healing, three-replica deployment. The same outcome with raw docker run commands would be… let's just say "not happening."

A real-world example: e-commerce in production

A typical e-commerce platform has several components:

A frontend web app
A product catalogue API
A user authentication service
A payment service
A database

Each one is built and packaged with Docker into its own container image — the frontend in one image, the API in another, authentication in a third, and so on.

In production, Kubernetes deploys all these images across a cluster of servers. It might run three replicas of the frontend, two of the API, two of authentication, and a single instance of the database with persistent storage.

When Black Friday traffic spikes, Kubernetes automatically scales the frontend to twenty replicas and the API to ten. When traffic falls, it scales them back down. If the authentication service crashes, Kubernetes restarts it within seconds without human intervention.

For local development, the same team would typically run the same containers with Docker Compose on each developer's laptop — same images, simpler orchestration, single machine. This is the most common pattern in 2026: Docker Compose locally, Kubernetes in production.

Docker Compose vs Kubernetes: when to use each

Docker Compose and Kubernetes both run multi-container applications, which is a frequent source of confusion. The practical distinction is scale and resilience.

Use Docker Compose when	Use Kubernetes when
Developing locally	Running in production
Running a small app on a single machine	Scaling across multiple servers
Prototyping a stack quickly	Need automatic failover
Building a CI test environment	Running microservices that must communicate reliably
Simplicity matters more than resilience	Zero-downtime rolling updates required

Most teams in 2026 use both: Docker Compose for local development, Kubernetes for staging and production. The container images are identical between environments — only the orchestration layer differs.

Which should you learn first?

Learn Docker first. The case is straightforward:

1. Kubernetes runs Docker containers. Without understanding how containers work, how images are built, how layers cache, how a process inside a container differs from a process on the host — Kubernetes concepts will not stick. Pods, deployments, services, and ConfigMaps all assume you already know what a container is.

2. Time investment. Docker takes two to three weeks to learn the basics; Kubernetes takes two to three months. Starting with Docker gives you early wins, builds confidence, and lets you ship real containerised applications before tackling the harder material.

3. Employability. Most DevOps job listings require Docker; only some require Kubernetes. Docker is the broader employable skill at the entry level. For smaller freelance projects on Upwork, Docker Compose is often enough — you may not need Kubernetes for the first two to three years of your DevOps career.

The recommended order:

Docker (2–3 weeks) — images, containers, Dockerfiles
Docker Compose (1 week) — multi-container apps
Kubernetes basics (4–6 weeks) — pods, deployments, services
Kubernetes in production (ongoing) — Helm, operators, observability

The DevOps Engineer Course at Sherdil E-Learning follows this exact sequence with hands-on labs and a final project that deploys a multi-container application to a real Kubernetes cluster.

Frequently asked questions

Is Kubernetes replacing Docker?

No. The deprecation of dockershim — Kubernetes's built-in adapter for the Docker engine — was announced in Kubernetes v1.20 (December 2020) and the code was removed in v1.24 (April 2022). This only changed how Kubernetes nodes run containers internally (they now use containerd or CRI-O directly). It did not affect how developers build Docker images. You still write Dockerfiles, you still run docker build, you still push to a registry. Kubernetes still runs your containers.

Can I use Kubernetes without Docker?

Technically yes. Kubernetes can use alternative container runtimes like containerd or CRI-O directly. In practice, most developers still use Docker locally to build images, and Kubernetes then runs those images via its container runtime. You do not need to avoid Docker; it is the most ergonomic tool for the build side of the workflow.

Do I need both for freelancing?

For most freelance projects on Upwork and Fiverr, Docker plus Docker Compose is sufficient. Kubernetes becomes relevant for full-time DevOps and SRE roles at companies running production microservices, or for larger international consulting engagements. Start with Docker; add Kubernetes when a specific job needs it.

Can I run Kubernetes on my laptop?

Yes. The three common options are:

Minikube — a single-node cluster running in a VM
kind — Kubernetes running inside Docker containers
Docker Desktop's built-in single-node Kubernetes

All three are free and run fine on a modern laptop with 8 GB of RAM or more.

How much does managed Kubernetes cost on AWS, Azure, and GCP?

AWS EKS — $0.10 per hour per cluster (~$73/month) plus the cost of the EC2 worker nodes.
Azure AKS — nothing for the control plane on the standard tier; you only pay for the worker VMs.
Google GKE Standard — $0.10 per hour per cluster beyond the first cluster per billing account. GKE Autopilot has a different per-pod pricing model.

Always verify current prices on the vendor sites — pricing changes periodically.

Do I need Linux experience to learn Kubernetes?

Yes — comfort with the Linux command line is effectively required. Most kubectl workflows assume you can read logs, inspect processes, work with files, and write small shell scripts. If your Linux is shaky, plan two to four weeks of Linux practice before starting on Kubernetes.

What certification should I aim for?

CKAD (Certified Kubernetes Application Developer) and CKA (Certified Kubernetes Administrator) are the two vendor-neutral credentials worth pursuing. Both are hands-on, practical exams (not multiple choice), which makes them more credible to hiring managers than typical IT certifications. CKAD is the lighter entry point for developers; CKA is the deeper certification for SREs and platform engineers.

Next steps

The right order is Docker first, then Docker Compose, then Kubernetes. Both tools are employable; together they are the foundation of every modern production deployment pipeline.

For a structured deep-dive, the DevOps Engineer Course at Sherdil E-Learning covers Docker, Docker Compose, Kubernetes, AWS, and Terraform in a single sequenced curriculum with hands-on labs.

About the author

💬 Found this useful? Drop a ❤️ or a 🦄, and let me know in the comments what you'd like the next deep-dive to cover — Helm charts, Kubernetes networking, or your first production deployment with EKS/AKS/GKE?

📖 Full original article:
elearning.sherdil.org/pages/kubernetes-vs-docker-difference

Terraform Tutorial for Beginners: Infrastructure as Code

E-Learning Sherdil — Wed, 03 Jun 2026 05:45:54 +0000

📌 This article was originally published on Sherdil E-Learning. I'm republishing it here so the dev.to community can benefit too.

If you have ever clicked through the AWS console, Azure portal, or GCP dashboard to create cloud resources, you know the pain: it's slow, hard to repeat reliably across staging and production, and easy to get wrong. Infrastructure as Code (IaC) solves this problem, and Terraform is the most widely used IaC tool in industry.

This guide takes you from "what is IaC" to running your first Terraform deployment on AWS, then walks through a working VPC + EC2 example you can adapt for production. It also covers the BUSL / OpenTofu split from 2023 that every Terraform learner in 2026 should understand.

What is Infrastructure as Code?

Infrastructure as code is the practice of managing cloud resources — servers, databases, networks, storage, security groups — through configuration files rather than manual clicks in a web console. You describe the infrastructure you want in text files, store those files in Git, and let an IaC tool create and update the real resources to match.

The practical benefits compound:

Repeatability — the same files produce the same infrastructure every time, which removes the "I forgot to open port 443" class of mistake.
Audit log built in — Git history becomes the audit log for every change, and pull requests become the review process.
Speed — a complete environment (VPC, subnets, instances, load balancer, database) can spin up in minutes instead of hours of console work.
Self-documenting — the configuration files double as documentation: anyone joining the team can read the Terraform code and understand exactly what is deployed.
Reusable patterns — once you have written a module for, say, a standard VPC, you can reuse it across every project with different inputs.

What is Terraform — and a note on OpenTofu

Terraform is an open-source-style infrastructure-as-code tool originally created by HashiCorp in 2014. It uses a declarative configuration language called HCL (HashiCorp Configuration Language) and supports hundreds of cloud and SaaS providers through a shared provider model.

One thing every Terraform learner in 2026 should know: in August 2023, HashiCorp changed Terraform's license from MPL 2.0 to the Business Source License (BUSL), which restricts commercial competitive use. In response, the OpenTofu project was forked from Terraform 1.5.5, kept the MPL 2.0 license, and is now maintained by the Linux Foundation.

OpenTofu is a drop-in replacement: same HCL syntax, same workflow, same provider ecosystem.

For learners, the practical difference is small. Terraform has more name recognition with employers, so start with Terraform for employability. If your future employer prefers OpenTofu, the switch is trivial. The rest of this tutorial works for both.

Official sites: terraform.io for Terraform; opentofu.org for OpenTofu.

Terraform vs other IaC tools

Tool	Scope	Language	Best for
Terraform	Multi-cloud (AWS, Azure, GCP, Alibaba, +hundreds)	HCL (declarative)	Teams working across more than one cloud
AWS CloudFormation	AWS only	YAML / JSON	AWS-only shops wanting tight native integration
Pulumi	Multi-cloud	Python, TypeScript, Go, C#	Teams that want a real programming language for infra
Ansible	Configuration management	YAML	Configuring software on existing servers (different category)

Terraform's biggest advantage is multi-cloud support — same syntax, every provider. CloudFormation is AWS-only and tightly integrated. Pulumi appeals to teams that want a real programming language. Ansible occupies a different category — it's better for configuring software on existing servers than provisioning the servers themselves.

How Terraform works: write, plan, apply

Terraform's daily workflow is three commands. Once you know what each one does, the rest of the tool makes sense.

Step 1: Write

Create .tf files (Terraform configuration files) that describe the infrastructure you want — resources like virtual machines, databases, networks, IAM roles. Each file is just plain text in HCL.

Step 2: Plan

terraform plan

Terraform reads your configuration files, compares them to the current state of your infrastructure, and shows you exactly what it will create, modify, or destroy — before changing anything. This is your safety net.

Step 3: Apply

terraform apply

Terraform executes the changes shown in the plan, calling the cloud provider's API to create, update, or delete resources to match your configuration.

There's also terraform destroy, which removes everything Terraform created — useful for tearing down test environments to avoid charges.

Core Terraform concepts

Five concepts come up constantly. Get comfortable with these and the rest of Terraform becomes a matter of looking up provider-specific resource names.

Providers

Plugins that let Terraform interact with specific cloud platforms or services. The AWS provider talks to the AWS API, the Azure provider talks to the Azure API, and so on. You declare which provider you need and Terraform downloads the right plugin during terraform init. Browse the full catalogue at registry.terraform.io.

Resources

The building blocks of your infrastructure. Each resource block defines one component — an EC2 instance, an S3 bucket, an IAM role, a VPC. The first label on a resource block is the type (e.g. aws_s3_bucket), the second is a name you choose for referring to this resource elsewhere in your code.

Variables

Variables make your code reusable. Instead of hard-coding values like the AWS region or instance size, you declare variables and pass values at apply time. The same Terraform code can then deploy a small dev environment or a large production environment by changing only the variable values.

State

Terraform maintains a state file (terraform.tfstate) that records what infrastructure Terraform currently manages. The state file maps your configuration to real-world resources, so Terraform knows what to update, what to leave alone, and what to destroy.

⚠️ State management is the single most important production concern. Never commit terraform.tfstate to Git, and use a remote backend (S3, Azure Blob, Terraform Cloud) for any team work.

Modules

Reusable packages of Terraform configuration. Think of a module as a function: you define one standard VPC setup, then call that module across staging, production, and every new project with different inputs. The Terraform Registry hosts thousands of open-source modules.

Your first Terraform project: a hands-on walkthrough

Before you start you need three things:

An AWS account with Free Tier access (sign up at aws.amazon.com).
AWS CLI installed and configured with your access keys (run aws configure after install).
Terraform installed — download from terraform.io or install via your package manager.

Step 1: Create a project directory

mkdir my-first-terraform && cd my-first-terraform

Step 2: Write a configuration file

Create a file called main.tf:

provider "aws" {
  region = "us-east-1"
}

resource "aws_s3_bucket" "my_bucket" {
  bucket = "my-first-terraform-bucket-replace-this-name"
}

This tells Terraform to use the AWS provider in us-east-1 and create an S3 bucket. Replace the bucket name with something globally unique — S3 bucket names must be unique across all of AWS.

Step 3: Initialise Terraform

terraform init

This downloads the AWS provider plugin. Run it once per project, plus again when you add new providers or change provider versions.

Step 4: Preview the changes

terraform plan

Terraform shows what it will do. In this case: 1 to add, 0 to change, 0 to destroy — creating one new S3 bucket. Always read the plan output before applying.

Step 5: Apply the changes

terraform apply

Type yes when prompted. Terraform creates the S3 bucket. Verify it in the AWS S3 console.

Step 6: Clean up

terraform destroy

Removes the S3 bucket so you don't incur any charges. Type yes to confirm. This matters: Terraform makes it easy to create real resources accidentally, so always destroy what you don't need.

A working VPC and EC2 example

A more realistic configuration that creates a VPC, an Internet Gateway, a public subnet with routing, a security group, and an EC2 instance that is actually reachable from the internet on port 80. The AMI is fetched dynamically so the example doesn't rot when AWS publishes a new Amazon Linux image.

provider "aws" {
  region = "us-east-1"
}

# Look up the latest Amazon Linux 2023 AMI dynamically
data "aws_ami" "amazon_linux" {
  most_recent = true
  owners      = ["amazon"]

  filter {
    name   = "name"
    values = ["al2023-ami-*-x86_64"]
  }
}

resource "aws_vpc" "main" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
  tags = { Name = "main-vpc" }
}

resource "aws_internet_gateway" "main" {
  vpc_id = aws_vpc.main.id
  tags   = { Name = "main-igw" }
}

resource "aws_subnet" "public" {
  vpc_id                  = aws_vpc.main.id
  cidr_block              = "10.0.1.0/24"
  map_public_ip_on_launch = true
  tags                    = { Name = "public-subnet" }
}

resource "aws_route_table" "public" {
  vpc_id = aws_vpc.main.id

  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.main.id
  }
}

resource "aws_route_table_association" "public" {
  subnet_id      = aws_subnet.public.id
  route_table_id = aws_route_table.public.id
}

resource "aws_security_group" "web" {
  vpc_id = aws_vpc.main.id

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

resource "aws_instance" "web" {
  ami                    = data.aws_ami.amazon_linux.id
  instance_type          = "t2.micro"
  subnet_id              = aws_subnet.public.id
  vpc_security_group_ids = [aws_security_group.web.id]
  tags                   = { Name = "web-server" }
}

Notice how resources reference each other:

The Internet Gateway attaches to the VPC (aws_vpc.main.id).
The route table sits inside the VPC and forwards 0.0.0.0/0 traffic to the gateway.
The route table is then associated with the public subnet so instances in that subnet can reach the internet.
The EC2 instance lives in the public subnet and uses the security group that allows port 80 inbound from anywhere.

Terraform works out the correct creation order automatically based on these references.

Best practices for beginners

Five habits to build from your first project, in order of how much pain they save you.

1. Always run terraform plan before terraform apply. Read the plan output carefully, particularly look for any destroy actions you didn't expect. One wrong configuration change can drop a production database. Treat plan output as a contract.

2. Use variables instead of hard-coded values. Region, instance type, environment name, CIDR blocks, tags — none of these should be hard-coded. Create a separate .tfvars file for each environment (dev.tfvars, staging.tfvars, prod.tfvars) and pass the right one at apply time.

3. Use a remote backend for state. Once more than one person works on the codebase, store terraform.tfstate in S3 (or Azure Blob, or Terraform Cloud) with state locking via DynamoDB. Never commit the state file to Git — it contains secrets in plain text.

4. Extract reusable patterns into modules. The first time you write a VPC, write it as plain resources. The second time, extract it into a module. By the third project you will save hours.

5. Tag every resource. At minimum tag with environment (dev / staging / prod), owner, and cost-centre. Untagged resources become impossible to attribute and trim when the AWS bill grows.

Frequently asked questions

Is Terraform free?

The Terraform CLI is free to download and use. Since August 2023 it is licensed under the Business Source License (BUSL) rather than fully open-source, which restricts commercial competitive use but not normal day-to-day work. Terraform Cloud has a free tier for small teams (up to 500 resources) and paid tiers for larger organisations. If you specifically want a fully open-source IaC tool, OpenTofu is the MPL-licensed fork.

Do I need to know programming to use Terraform?

No general-purpose programming is required. HCL is a configuration language, closer to JSON or YAML than to Python. If you can read and edit a JSON file, you can write Terraform. The mental model for variables, references, and modules will take a week or two but doesn't require previous coding experience.

Should I learn Terraform or CloudFormation first?

If you work exclusively with AWS, either tool is fine. If you work with multiple cloud providers, or want the broadest job market, learn Terraform. Most DevOps job listings that mention IaC list Terraform first. Some AWS-only shops still use CloudFormation for tighter integration with AWS services.

What is OpenTofu and should I use it instead of Terraform?

OpenTofu is a Linux Foundation-maintained fork of Terraform 1.5.5, created in September 2023 after HashiCorp moved Terraform to the BUSL license. It keeps the MPL 2.0 open-source license and is largely a drop-in replacement — same HCL syntax, same workflow, same provider ecosystem. For learning, start with Terraform because more employers list it by name. Switching to OpenTofu later is straightforward if your company prefers it.

How do I store Terraform state safely?

Never commit terraform.tfstate to Git — it can contain secrets in plain text. For team work, use a remote backend: S3 with DynamoDB-based state locking is the most common AWS pattern; Terraform Cloud is the easiest if you want a managed solution; Azure Blob Storage and Google Cloud Storage work for Azure and GCP-centric teams. Configure the backend block in your Terraform configuration and run terraform init to migrate.

Can I use Terraform with Azure and GCP, not just AWS?

Yes — Terraform's biggest strength is multi-cloud support. The Azure provider (azurerm), Google Cloud provider (google), Alibaba Cloud provider (alicloud), and hundreds of others all use the same workflow. The configuration syntax is the same; only the resource names change.

How long does it take to learn Terraform?

You can deploy your first Terraform configuration in one to two weeks of part-time study. Becoming proficient with modules, remote state, workspaces, and production patterns takes two to three months. The Terraform Associate certification typically takes four to six weeks of preparation on top of basic familiarity.

Next steps

The order I recommend at Sherdil:

Get comfortable with the six-step S3 walkthrough above.
Build the VPC + EC2 example end-to-end.
Learn variables and modules.
Set up a remote backend.
Book the HashiCorp Certified: Terraform Associate (003) exam — multiple-choice, ~$70 USD, the entry-level cert employers recognise.

For a structured deep-dive, the Mastering Terraform Course at Sherdil E-Learning covers everything above in depth plus the production-pattern material needed for the Terraform Associate exam. For learners who want IaC in the context of a full DevOps stack, the DevOps Engineer Course sequences Terraform alongside Docker, Kubernetes, AWS, and CI/CD.

About the author

💬 Found this useful? Drop a ❤️ or a 🦄, and let me know in the comments what you'd like the next deep-dive to cover — remote backends, modules, or a Terraform Cloud walkthrough?

📖 Full original article:
elearning.sherdil.org/pages/terraform-tutorial-beginners-iac

DEV Community: E-Learning Sherdil

AWS vs Azure vs GCP (2026): Which Cloud Certification Should You Get First?

At-a-glance comparison

AWS: the safest first pick for most candidates

Azure: the enterprise and government choice

GCP: the data, AI, and premium-freelance specialist

Freelance rate snapshot (Upwork, 2026)

Which one should you pick first?

The multicloud advantage

Frequently asked questions

Which cloud certification is easiest to pass?

How long does it take to get certified?

How much do these certifications cost?

Can I get a cloud job without a degree?

Will AI tools replace cloud engineers?

Can I work remotely for international companies?

Is it worth getting certified in 2026?

Next steps

About the author

Docker for Beginners (2026): From Zero to Your First Dockerfile

What is Docker?

Why Docker is a high-return skill in 2026

Docker vs virtual machines

Core Docker concepts you need to know

Docker image

Docker container

Dockerfile

Docker Hub

Docker Compose

Installing Docker, step by step

Windows

Ubuntu (official Docker apt repository)

macOS

Your first Docker container: hands-on tutorial

Writing your first Dockerfile

Docker in the real world: how modern teams use it

Docker commands cheat sheet

Frequently asked questions

Is Docker free to use?

Can I learn Docker without knowing Linux?

How long does it take to learn Docker?

Should I learn Docker or Kubernetes first?

What is the difference between docker run and docker compose up?

Can I use Docker on Windows without WSL 2?

Next steps: from Docker to a DevOps career

About the author

Kubernetes vs Docker (2026): What's the Difference and Which Should You Learn First?

Docker: the container creator

Kubernetes: the orchestration layer above Docker

Side-by-side comparison

How Docker and Kubernetes work together in a real deployment

What a Kubernetes manifest actually looks like

A real-world example: e-commerce in production

Docker Compose vs Kubernetes: when to use each

Which should you learn first?

Frequently asked questions

Is Kubernetes replacing Docker?

Can I use Kubernetes without Docker?

Do I need both for freelancing?

Can I run Kubernetes on my laptop?

How much does managed Kubernetes cost on AWS, Azure, and GCP?

Do I need Linux experience to learn Kubernetes?

What certification should I aim for?

Next steps

About the author

Terraform Tutorial for Beginners: Infrastructure as Code

What is Infrastructure as Code?

What is Terraform — and a note on OpenTofu

Terraform vs other IaC tools

How Terraform works: write, plan, apply

Step 1: Write

Step 2: Plan

Step 3: Apply

Core Terraform concepts

Providers

Resources

Variables

State

Modules

Your first Terraform project: a hands-on walkthrough

What is the difference between `docker run` and `docker compose up`?