Lesson 1 of 7 in DevOps and delivery fundamentals
What DevOps is and why teams adopted it
DevOps is a way of working where the people who build software and the people who run it share responsibility for getting changes to users quickly and safely. It relies on automation to replace manual handoffs and on feedback from running systems to guide the next change.
Draft. This lesson is written and waiting for a person to run every command and review it. It is safe to learn from, but check the official documentation for anything you depend on.
The problem this solves
Building software and running it used to be separate jobs with opposite incentives. Developers were rewarded for shipping change. Operations were rewarded for keeping things stable, so change looked like a risk to them.
A release crossed that gap as a handoff: a ticket, a wait, a manual deployment from a checklist, and a surprise when production differed from what the developers had tested. Each handoff added delay, and nobody owned the whole path from idea to working feature.
DevOps closes the gap. One team owns the change from commit to production, writes the repeatable steps down as scripts, and watches the result. The aim is to make shipping a routine, low-drama event.
How it works
- People and clients
- Other
- Runs code
A developer files a request into a queue, waits, and a separate operations group deploys by hand into production.
- Developers to Ticket queue: 1 request deploy
- Ticket queue to Operations: 2 wait
- Operations to Production: 3 manual steps
- People and clients
- Control
- Runs code
- Data
One team pushes a change through an automated pipeline into production, users use it, monitoring reports what happened, and the team acts on that.
- One team to Pipeline: 1 push change
- Pipeline to Service: 2 release
- Users to Service: 3 use it
- Service to Monitoring: 4 emit signals
- Monitoring to One team: 5 learn and fix
The first picture shows where time disappears. Nothing in it is slow work. The time goes into queues and handoffs between people who each see only part of the path.
The second picture removes the wall. The same team that writes the change pushes it into a pipeline, which is a script that runs the same steps every time. The pipeline releases to production, and monitoring reports back what the running service is doing.
Step 5 is the part beginners overlook. Without signals coming back from production, automation only helps you make mistakes faster.
Try it yourself
Run this in a Linux or macOS terminal, or WSL on Windows. It creates one throwaway folder and nothing else. You will turn a manual checklist into a script.
- 1Make a tiny app and a lab folder
mkdir -p ~/devops-lab/fundamentals && cd ~/devops-lab/fundamentals echo 'echo "hello from v1"' > app.sh
app.shstands in for your real application. The folder is throwaway, so you can delete~/devops-labwhen you finish the topic. - 2Write the release checklist as a script
cat > release.sh <<'EOF' set -e sh -n app.sh mkdir -p live cp app.sh live/app.sh echo "released $(date)" >> releases.log EOF
sh -nchecks syntax without running the file.set -estops the script at the first command that fails. Each line is a step someone used to do from memory. - 3Run the release and check the result
sh release.sh cat releases.log sh live/app.sh
You should see
hello from v1
cat releases.logshows one line with the release time. The last command runs the released copy, so the printed text proves the release worked. Runsh release.shagain and the log gains a second line, which is a record nobody had to remember to write.
What breaks, and where to look
The team says it does DevOps, yet releases still wait on a ticket to a separate group and happen rarely.
- WHY IT HAPPENS
- DevOps was treated as a job title or a tool purchase. The handoff stayed in place and only its name changed.
- CHECK FIRST
- Trace the last release from merged change to production. Write down every handoff and every wait with its duration. The longest wait is where to start.
You adopted a popular tool such as a CI server or Kubernetes and delivery is no faster.
- WHY IT HAPPENS
- The slow part was somewhere a tool does not reach, such as manual approvals, long-lived branches, or flaky tests that people re-run by hand.
- CHECK FIRST
- Take one recent change and list its timestamps: first commit, merge, build finished, deployed. Look for the biggest gap before choosing any tool.
When not to use this
- A single developer shipping rarely does not need a full pipeline. A short script like
release.shcaptures most of the value. - Shared ownership does not remove specialists. Security, databases and networking still need deep expertise. DevOps changes who is involved early, not whether the skills matter.
Check yourself
What problem does DevOps address?
Slow, risky releases caused by handoffs between separate teams with opposite incentives and nobody owning the whole path to production.
Why does the loop need monitoring, not only a pipeline?
Signals from production tell the team whether the change worked, so the next change is guided by facts. Without them automation just ships faster without learning.
What did turning the checklist into release.sh give you?
The steps run the same way every time, stop on failure, and leave a record, instead of depending on someone's memory.
Lesson 1 of 92 in the DevOps path