Confusing DevOps Terms Explained in Simple Words

DevOps · Simple Explanations

Confusing DevOps Terms Explained in Simple Words

SECTION 01Delivery pairs: CI, CD and release

"CI/CD" is often said as one word, but it covers three different ideas. Continuous Integration means developers merge small changes frequently and every merge is built and tested automatically. Continuous Delivery means the software is always in a releasable state, with a human deciding when to release. Continuous Deployment goes one step further: every change that passes the pipeline goes to production automatically.

name: ci
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      - run: npm ci
      - run: npm test

deploy-production:
  needs: test
  runs-on: ubuntu-latest
  environment: production      # requires manual approval if configured
  steps:
    - run: ./deploy.sh

# Continuous DELIVERY: the job waits for a person to approve.
# Continuous DEPLOYMENT: remove the approval rule so it
# runs automatically whenever tests pass.

SECTION 02Container pairs: VMs, images and orchestrators

Containers are probably the most confused area for beginners. A virtual machine includes a full operating system on virtual hardware; a container shares the host's kernel and packages only the app and its dependencies, so it starts faster and uses less space. An image is the read-only blueprint; a container is a running instance of it. Docker builds and runs containers; Kubernetes runs and manages many containers across many machines.

docker build -t myapp:1.0 .        # creates an IMAGE
docker images                      # list images (blueprints)

docker run -d --name app1 -p 8080:80 myapp:1.0   # CONTAINER 1
docker run -d --name app2 -p 8081:80 myapp:1.0   # CONTAINER 2
docker ps                          # list running containers

# One image, many containers.

# docker-compose.yml — several containers on ONE machine
services:
  web:
    image: myapp:1.0
    ports: ["8080:80"]
  cache:
    image: redis:7

# Kubernetes — many replicas across MANY machines
# kubectl create deployment web --image=myapp:1.0 --replicas=3
# kubectl get pods -o wide   (shows which node each pod runs on)

SECTION 03Operations pairs: watching systems in production

Once software runs, teams need to know whether it is healthy. Monitoring watches known signals with dashboards and alerts — CPU, error rates, response times. Observability is the ability to understand new, unexpected problems by exploring metrics, logs and traces together. Reliability targets have their own confusing trio: SLI is what you measure, SLO is the target you set, and SLA is the promise you make to customers.

# SLI: share of successful requests over 30 days (PromQL)
sum(rate(http_requests_total{job="api", code!~"5.."}[30d]))
/
sum(rate(http_requests_total{job="api"}[30d]))

# SLO: we target this to be >= 0.995 (99.5%)
# SLA: the customer contract may promise, say, 99.0%

import json, logging, time

logging.basicConfig(level=logging.INFO, format="%(message)s")

def log_request(path, status, ms, trace_id):
    logging.info(json.dumps({
        "ts": time.time(), "path": path, "status": status,
        "duration_ms": ms, "trace_id": trace_id,
    }))

log_request("/api/orders", 500, 812, "abc123")
# Structured logs with a trace_id let you connect logs,
# metrics and traces when investigating a problem.

SECTION 04DevOps pair-learning template

Use this template whenever you meet a new pair of DevOps terms that sound alike.

Term A:
Term B:
A in one line:
B in one line:
Everyday analogy:
Command or config example:
When A is used:
When B is used:

- Infrastructure as code vs configuration management
  (Terraform vs Ansible)
- Rolling update vs blue-green deployment
- Horizontal vs vertical scaling
- Stateless vs stateful services
- Liveness vs readiness probe
- Push vs pull deployment (CI push vs GitOps pull)
- Artefact repository vs container registry

For each pair, practise a 30-second answer:
1. A in one sentence
2. B in one sentence
3. The key difference
4. A real situation for each
Then add: "In my lab, I ..."

SECTION 05Tips for explaining DevOps terms

Clear explanations show real understanding:

• Place each term in the flow — code, build, ship or run.
• Use one analogy per pair — keep it simple and memorable.
• Show a command — "docker run creates a container from an image" is concrete.
• Mention trade-offs — continuous deployment needs strong tests and monitoring.
• Avoid buzzword stacking — explain one idea fully before adding another.

SECTION 06Interview Q&A — confusing DevOps terms

SECTION 07Test yourself — confusing DevOps terms quiz

SECTION 08Frequently asked questions

SECTION 09Related reads