The culture, the lifecycle, and why it exists — in plain English.
Module 1 · The foundation. No tools yet — just the big picture.
Beginner Foundations ~25 minPrerequisites: None. This is the very first step.
Traditionally, software was built by two teams with opposite goals:
| Developers (Dev) | Operations (Ops) |
|---|---|
| Want to ship new features fast | Want to keep systems stable |
| "Here's my code, run it." | "Your code broke our servers." |
| Rewarded for change | Rewarded for no change |
They threw work "over the wall" at each other. Releases were rare, scary, and manual. When something broke, each side blamed the other. This conflict is the famous Dev vs. Ops silo.
DevOps is a culture and set of practices that tears down that wall — so teams build, ship, and run software together, with automation handling the repetitive, error-prone parts. The goal: deliver value to users faster and more reliably.
DevOps is not a job title you can buy, a single tool, or "just automation." It's primarily a way of working. The tools (Docker, Kubernetes, CI/CD…) exist to support the culture — not the other way around.
DevOps is often drawn as an infinity loop — because software is never "finished." You continuously build, run, learn, and improve:
| Stage | What happens | Course module |
|---|---|---|
| Plan | Decide what to build | — |
| Code | Write it; track with version control | Git (Mod 4) |
| Build | Package into a runnable artifact | Docker (Mod 6) |
| Test | Automatically verify it works | CI/CD (Mod 9) |
| Release / Deploy | Ship it to servers | K8s, CI/CD (Mod 8, 9) |
| Operate | Run the infrastructure | IaC (Mod 10) |
| Monitor | Watch health; feed learnings back to Plan | Monitoring (Mod 11) |
Every module you'll do maps to a stage above. By the end you'll have automated the entire loop for one real app — which is exactly what a DevOps engineer does.
| Practice | What it means |
|---|---|
| Automation | Let machines do repetitive work — builds, tests, deploys. Humans make mistakes; scripts don't. |
| CI/CD | Continuous Integration & Delivery — every change is automatically tested and shipped. |
| Infrastructure as Code | Define servers in version-controlled files, not by clicking around. |
| Containers | Package apps so they run identically everywhere. |
| Monitoring & feedback | Measure everything; use data to improve continuously. |
Instead of one giant scary release a quarter, DevOps teams ship tiny changes many times a day. Small changes are easier to test, safer to deploy, and trivial to roll back. Automation makes that pace possible.
Tools are easy; culture is the hard part. CALMS is a handy model for what a healthy DevOps culture looks like:
| Letter | Principle |
|---|---|
| Culture | Shared ownership and collaboration over blame and silos. |
| Automation | Automate repetitive tasks to remove toil and human error. |
| Lean | Work in small batches; eliminate waste; improve flow. |
| Measurement | You can't improve what you don't measure. |
| Sharing | Share knowledge, tools, and responsibility openly. |
SRE (Site Reliability Engineering — Google's take on DevOps), GitOps (managing infra through Git), and DevSecOps (building security into the pipeline). They're all flavors of the same core idea.
No terminal yet — this one is about understanding. Spend 10 minutes on these. Writing the answers down makes the rest of the course click.
Sketch the 8-stage infinity loop from memory. Next to each stage, write one tool you think might help there (guesses are fine — you'll learn the real ones soon).
Think of any group project you've done. Where did work get "thrown over a wall"? What broke as a result? That friction is exactly what DevOps targets.
Write one sentence: "If every code change were automatically tested and deployed, then ______." Keep it — revisit it after the Capstone.
Throughout this course you'll build and ship one small web app — a "notes" app. You'll carry it through every stage of the loop above. By Module 13 it'll be live on the internet, deploying itself on every change.
| Term | Plain meaning |
|---|---|
| Pipeline | An automated assembly line for code (test → build → deploy). |
| Artifact | The packaged output of a build (e.g. a container image). |
| Environment | Where code runs: dev, staging, production. |
| Rollback | Reverting to the previous working version when something breaks. |
| Toil | Repetitive manual work that should be automated. |
What DevOps is (a culture + practices, not a tool), the problem it solves (Dev/Ops silos), the lifecycle loop, the core practices, and the CALMS culture behind it. That's the map for everything ahead.
Next up: Module 2 — Linux Essentials. Almost all DevOps tooling runs on Linux, so we start by getting you comfortable in the terminal.