DevOps · Beginner's Guide
DevOps for Beginners: Tools, Skills and Resources
Picture a small team that deploys its app by copying files to a server by hand every second Friday. Each release takes an evening, something always breaks, and nobody is sure which change caused it. DevOps is the answer to that situation: developers and operations people share responsibility for running software, and they automate the path from a code change to production so it can happen often, safely and repeatably.
DevOps is a way of working first and a set of tools second. Still, as a beginner you learn it through the tools, so this guide covers both.
The core ideas in plain words
- Small, frequent changes: a small change is easier to test, review and roll back than a big one.
- Automate the repeatable: builds, tests, deployments and server setup should run from scripts, not memory.
- Everything as code: application code, pipeline definitions, infrastructure and configuration all live in Git.
- Measure and get feedback: monitoring and logs tell you quickly when a change hurts users.
- Shared ownership: "it works on my machine" is not the end of a developer's job.
Teams often measure DevOps performance with the four DORA metrics from Google's DevOps Research and Assessment programme: deployment frequency, lead time for changes, change failure rate and time to restore service.
The tools, in the order to learn them
| Order | Area | Start with | Why at this point |
|---|---|---|---|
| 1 | Linux and the shell | Ubuntu, bash, ssh, file permissions, processes, systemd | Almost every server and container runs Linux |
| 2 | Networking basics | IP, DNS, ports, HTTP/HTTPS, load balancers | Most production problems are network problems in disguise |
| 3 | Git | Branches, merges, pull requests | Every later tool is triggered by Git events |
| 4 | A scripting language | Bash plus Python | Glue for automation tasks |
| 5 | CI/CD | GitHub Actions or GitLab CI, then Jenkins | Automates build and test on every change |
| 6 | Containers | Docker, Docker Compose | Same environment from laptop to production |
| 7 | A cloud platform | AWS, Azure or Google Cloud fundamentals | Where most pipelines deploy to |
| 8 | Infrastructure as code | Terraform; Ansible for configuration | Servers and networks created from code |
| 9 | Orchestration | Kubernetes | Running many containers reliably; learn it after Docker, not before |
| 10 | Monitoring | Prometheus, Grafana, centralised logs | Knowing that something broke before users tell you |
Beginners often jump straight to Kubernetes because it appears in job posts. Without Linux, networking and Docker underneath, it becomes memorised commands. A longer description of each tool is in top DevOps tools to learn.
Your first pipeline, step by step
The quickest way to understand DevOps is to build one continuous integration (CI) pipeline. Take a tiny Python function that adds 18% GST to a price:
# app.py
def gst_inclusive(price, rate=18):
"""Return price including GST, rounded to 2 decimals."""
if price < 0:
raise ValueError("price cannot be negative")
return round(price * (1 + rate / 100), 2)
Step 1: write tests. Automation is pointless without checks to run:
# test_app.py
import unittest
from app import gst_inclusive
class TestGst(unittest.TestCase):
def test_default_rate(self):
self.assertEqual(gst_inclusive(100), 118.0)
def test_custom_rate(self):
self.assertEqual(gst_inclusive(250, rate=5), 262.5)
def test_negative_price(self):
with self.assertRaises(ValueError):
gst_inclusive(-1)
if __name__ == "__main__":
unittest.main()
Running python -m unittest -v locally gives:
test_custom_rate (test_app.TestGst.test_custom_rate) ... ok
test_default_rate (test_app.TestGst.test_default_rate) ... ok
test_negative_price (test_app.TestGst.test_negative_price) ... ok
----------------------------------------------------------------------
Ran 3 tests in 0.000s
OK
Step 2: push the code to GitHub (see Git and GitHub for developers if this is new).
Step 3: add a workflow file at .github/workflows/ci.yml, so GitHub runs the tests on every push and pull request:
name: CI
on: [push, pull_request]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: "3.12"
- run: python -m unittest -v
Step 4: break it on purpose. Change 18 to 12 in app.py, push, and watch the pipeline fail with a red cross on the commit. Fix it and watch it turn green. That loop, where every change is checked automatically before anyone merges it, is continuous integration.
Step 5: extend it. Add a Dockerfile and a step that builds the image; then deploy the container to a cloud service when the main branch passes. Each extension teaches one more tool from the table. The same idea in Jenkins is covered in CI/CD pipelines with Jenkins, and containers in Docker basics for beginners.
Skills employers check
- Comfort on a Linux command line, including reading logs and finding why a service will not start.
- Writing and debugging a CI/CD pipeline.
- Building and running containers, and explaining image layers and volumes.
- One cloud platform's basics: compute, networking, identity and access, storage. Practice questions are in AWS interview questions.
- Infrastructure as code for at least a small environment.
- Troubleshooting under pressure and writing clear incident notes.
More on how these are weighed in hiring is in skills for a career in DevOps.
Free resources worth using
- Pro Git by Scott Chacon and Ben Straub, free on git-scm.com.
- Official docs and tutorials: Docker's "Get started" guide, the Kubernetes documentation tutorials, GitHub Actions documentation, Terraform's tutorials on HashiCorp's site.
- Cloud free tiers: AWS, Azure and Google Cloud all offer free-tier or trial credits; set a billing alert on day one.
- Site Reliability Engineering, Google's book on running production systems, readable free on sre.google.
- The Phoenix Project (a novel) and The DevOps Handbook for the culture side.
Whether a paid course is worth it on top of these depends on how you learn; free vs paid DevOps courses lays out the trade-offs.
A realistic first three months
- Month 1: Linux, networking basics, Git. Host a static site on a small Linux server you set up yourself.
- Month 2: the pipeline above, then Docker and Docker Compose for an app with a database.
- Month 3: one cloud platform and Terraform; deploy your containerised app from the pipeline.
Kubernetes and monitoring come after that. Many people enter DevOps from system administration, support, testing or development roles, because those jobs already give practice in one half of the work.