Lesson 1 of 7 in DevOps and delivery fundamentals

What DevOps is and why teams adopted it

Core7 min

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

The old handoff: waiting at every step
The old handoff: waiting at every stepA developer files a request into a queue, waits, and a separate operations group deploys by hand into production.1 requestdeploy2 wait3 manualstepsDeveloperswrite the changeTicket queuewaits for a turnOperationsdeploys by handProduction
  • 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.

  1. Developers to Ticket queue: 1 request deploy
  2. Ticket queue to Operations: 2 wait
  3. Operations to Production: 3 manual steps
The DevOps loop: one team, automated path, feedback
The DevOps loop: one team, automated path, feedbackOne team pushes a change through an automated pipeline into production, users use it, monitoring reports what happened, and the team acts on that.1 pushchange2 release3 use it4 emit signals5 learn and fixOne teambuilds and runsPipelineautomated stepsServicerunning in productionUsersMonitoringmetrics, logs, alerts
  • 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.

  1. One team to Pipeline: 1 push change
  2. Pipeline to Service: 2 release
  3. Users to Service: 3 use it
  4. Service to Monitoring: 4 emit signals
  5. 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.

  1. 1
    Make a tiny app and a lab folder
    mkdir -p ~/devops-lab/fundamentals && cd ~/devops-lab/fundamentals
    echo 'echo "hello from v1"' > app.sh

    app.sh stands in for your real application. The folder is throwaway, so you can delete ~/devops-lab when you finish the topic.

  2. 2
    Write 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 -n checks syntax without running the file. set -e stops the script at the first command that fails. Each line is a step someone used to do from memory.

  3. 3
    Run the release and check the result
    sh release.sh
    cat releases.log
    sh live/app.sh

    You should see

    hello from v1

    cat releases.log shows one line with the release time. The last command runs the released copy, so the printed text proves the release worked. Run sh release.sh again 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.sh captures 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

Search

Search cheat sheets and projects