Skip to content


We've just done a lot of work. We've written lots of files, triggered some pipelines and reviewed the results. The questions we should be asking now: what did we do and why?

What did we just do, exactly?

Our goal for this section was to build some pipelines and then have them automatically run when we made changes to our code, and that's exactly what we just did. More precisely we just:

  1. Automated the IAC stage
  2. Automated the software packaging stage
  3. Automated the CAC stage

Building out these CI pipelines involved writing a few .gitlab-ci.yml files and the end results were fully automated pipelines.

Why did we bother doing that?

With those stages automated we did something very important: we removed the human.

These pipelines had to be built so we could implement the DevOps practice of removing the human from the process of doing things that computers are way, way better at doing. And this is important work.

Without automated CI pipelines software development would be slow and error prone. Things get missed or are forgotten, or just plain done wrong. You can write the best run books in the world, but miss one step and your end results will vary and introduce instability and uncertainty.

We would need a lot of time to get basic tasks done, like compiling and packaging up our application, before we even got into the time sink of deploying our application. And all of this doesn't even include the time it takes to fix problems that come out of manual compilation, testing and deployment practices.

Instead of putting up with this, we've built some CI pipelines that take the human (mostly) out of the process and let the computer do the work for us.

Computers are very good at repeating processes over and over, so let's get them to do the work for us.


The next phase of the book is coming soon.