The short answer: you don’t need to be a software developer, but you can’t do DevOps or cloud work without reading and writing code. The original version of this post said coding was “not a must”. Three years on, after running real systems, I’d put it more firmly than that.
The useful question isn’t “do I need to code?” It’s “what kind of code, and how well?” This post answers that with four real bugs from my homelab, Project Aether. Each one was a few lines long, and each one needed someone who could read code to find it.
The code DevOps work involves #
It’s not the code a product developer writes. There are no user interfaces and rarely any algorithms. It’s mostly short programs that glue systems together.
| Kind | Language | Example |
|---|---|---|
| Automation scripts | Bash | A nightly backup: dump the databases, upload them, check the result |
| Tools and checks | Python | Compare what’s running with what Git says should be running |
| Configuration | YAML, HCL, JSON | Kubernetes manifests, Terraform files, CI pipelines |
| Small extensions | Whatever the tool uses | A health check written in Lua inside a Kubernetes tool |
| Reading other people’s code | Usually Go | Working out why Kubernetes, Docker or Terraform did something surprising |
Configuration files aren’t programming in the classic sense, but they behave like code: they have syntax, they have bugs, and a typo can take a system down. Treat them with the same care.
Four bugs that needed someone who could code #
1. One character in Bash. My backup script sent a “heartbeat” to my monitoring system when it finished. The heartbeat URL contained & characters, and the config file that held it was loaded with Bash’s source command. To Bash, & means “run this in the background”, so the URL was cut off and the variable ended up empty. The script had || true after every command, which tells Bash to ignore failures, so it printed “Backup Complete!” every night while the heartbeat never arrived. Finding it took knowing how Bash parses a line. Fixing it took quoting, and set -Eeuo pipefail at the top so any failure stops the script.
2. A dictionary comparison in Python. The tool that deploys my Kubernetes apps can’t manage its own installation, so that installation drifted from Git for three weeks without anyone noticing. The fix was about fifteen lines of Python: load the live settings and the settings in Git, compare them, and fail loudly if they differ. Nothing clever, but it needed someone comfortable writing it.
3. A nil check in Lua. A Kubernetes tool needed a small custom script to report the health of the apps it manages. A brand-new app has no status yet, so the script needs a check for missing data, or it fails exactly when a new app appears. One if ... ~= nil handles it. Lua isn’t a language most DevOps engineers know, but being comfortable in one language makes another readable quickly.
4. A setting that did nothing in YAML. I added a DNS setting to a Helm chart’s configuration file to make my log shipper find the right server. The chart had no such setting, and Helm ignores unknown keys silently, so the line did nothing, and two of three servers sent their logs nowhere for days. Finding that meant reading the chart’s templates to see what it actually used. That’s reading code too.
None of these needed a computer science degree. All four needed someone who could read code carefully and write a small, correct fix.
Which languages to learn #
If you’re starting out, learn them in this order:
- Bash. You’ll use it every day. Learn variables, quoting,
if, loops, exit codes andset -euo pipefail. Most production scripts in operations are Bash. - Python. For anything longer than about 50 lines, or anything that parses JSON or YAML, or talks to an API. It’s readable, and every cloud has a Python SDK.
- Go, to read. Docker, Kubernetes, Terraform and Prometheus are all written in Go. You don’t need to write Go to start a DevOps job, but being able to read it means you can find out what a tool really does when the documentation runs out. (My Go series is a gentle start, and so is this repo.)
Alongside these, get comfortable with YAML and JSON syntax, and learn how to read a stack trace and an error message slowly instead of searching for it straight away.
So, is it essential? #
If “coding” means building applications, no. Plenty of excellent DevOps and cloud engineers never write a product feature.
If it means reading a script and spotting why it lies, writing a small tool that checks your systems, and reading the source of a tool to see why it behaved the way it did, then yes. That’s a large part of the job, and it’s the part that separates someone who can follow a runbook from someone who can fix what the runbook didn’t cover.
The good news is that this level is very learnable. Start with Bash, automate one thing you do by hand, and go from there.
That’s the last post in Mysteries of DevOps for now. If you want to see these ideas in a real system, the Project Aether series is where they’re put to work.