In partnership with

Pay less than half for every GitHub Actions run

Coding agents help you ship faster. They also make your GitHub Actions bill grow.
On private repos, once your free minutes run out, you pay for every push, PR and rerun. More code from agents means more runs and a bigger bill.
WarpBuild cuts that bill in two ways:
💰 33% cheaper per minute: $0.004 vs GitHub's $0.006
⚡ Shorter runs: my Rust build went from 91s to 52s on the same size machine
Together, that's less than half the cost per run.
Switching takes one line in your workflow file. No rewrites, no migration.
See what it saves on your own pipeline, with $50 free.
👉 Get $50 in free credits, code START50
Every Tuesday - Deep dives, architecture lessons, and real engineering stories.
Every Saturday - The best DevOps, SRE, Cloud, AI, tools, tutorials, and projects from the week.
I recently polled my new subscribers to my newsletter Uptime Engineer: Tell me something you are stuck on.
I got a few hundred responses, with many mentioning AI in some form. "I am stuck worrying about AI stealing my job." / "What roles are safe from AI?" were some of them.
Completely understandable.
You can spin up any LLM and get it to produce a working docker file, terraform configuration, CI workflow etc within seconds. In the past it would have taken a junior SRE/devops engineer hours.
If you've recently started out, you may be wondering how you can make yourself useful in this new landscape.
Let me paint a picture from my experience working on production systems day in, day out.
It has made generating code easier and cheaper. It hasn't made deploying and running that code in production easier and cheaper.
Every piece of code that is generated by AI will still need to be deployed and run on a server, resolved via DNS, served over a load balancer, over TLS etc, backed by a datastore and monitored. More code is being written => more code will be running in production => more failures.
Which brings us to the crux of the question: What to do when it fails?
There is no AI that can help you answer this question. You have to understand why your system failed.
There are no courses out there, or YouTube videos with millions of views teaching you this. But it is what makes senior engineers useful and some juniors indispensable to their team so quickly.
Don't stop writing code. Continue to do so. It's just that writing code isn't the scarce skill any more.
In this issue:
How most people are learning devops and why that doesn't make you useful when things fail
A shift in my thinking and a habit I've developed that I've dubbed "Underneath thinking"
5 simple steps you can follow to become this person
Everyone Is Learning To Build. Almost Nobody Is Learning Why It Breaks.
Most people follow a similar path to learn devops. They follow a tutorial/online course, copy-paste the commands as they go and build some application. Once they've completed that, they maybe repeat this process and learn to build the next thing. Earn the next cert.
I've labelled this "learning on paper".
You never learn why things fail when learning on paper. The tutorial/course was designed to succeed and any errors the author faced were corrected prior to the video being published. You learn how things should look in a successful state. You don't learn how to identify and recover from failures.
This is a huge proportion of what you'll do at a job.
Let me take you through a typical scenario.
It's Friday. A few months after you've joined your first job as a SRE/DevOps engineer, users begin reporting that they cannot access your application. You navigate to your monitoring stack and see a flood of 502 errors.
Your first instinct is to copy-paste the error into an LLM and ask it for help.
The LLM will return something along the lines of: "Increase the upstream timeout / restart your service / investigate application code". You'll follow these instructions to no avail.
The response isn't incorrect, but isn't helpful for your specific problem. A 502 only tells you that the response returned to your client by the intermediate service (e.g. proxy) was an error. It doesn't tell you if it's your application or something in between that's failing. You can't provide this additional context to the LLM because you don't know it either!
All you've told the LLM is that you're seeing a 502. You haven't told it where in the system it's failing.
An experienced engineer will spend some time understanding where in the system it's failing.
Was the request even sent to our infrastructure? Was the 502 generated by our proxy or application? What are the logs at the relevant time period showing?
After that, they can narrow down where to start investigating, and use an LLM to help analyse the relevant logs/configs.
This is also the order of actions suggested in Google's SRE handbook: Analyse problem report -> examine logs -> generate test request -> hypothesise.
How did I learn to do this?
By failing, many times.
I was working on my product DigBizCards in 2020, which allowed customers to set up a custom domain with automatic TLS cert setup. I was unable to find any courses that taught me how to do this. I asked on various forums to no success.
Eventually I got help from 2 engineers (Siva and Oliver) who had implemented this before to explain the underlying mechanics of domain resolution and TLS certs using Caddy, which allowed me to solve my issue.
What stood out to me was how these engineers explained the concepts and what was going on at each stage of the process, instead of simply telling me to execute a command. I've never forgotten that.
Fast forward to 2022 where I started my own web hosting service and ran it for ~8 months. This was effectively my best "course" on Linux/networking I've taken. I had many customers who I had no idea what they'd try and run on my servers (shout out to the crypto miners!) and inevitably ran into many issues that I had to figure out for myself.
After that, in 2023 I started working as an SRE intern at PhonePe, with a CGPA of 7.2 and a number of failed projects on my resume. I was eventually responsible for operating PhonePe's largest Nginx cluster (>1B requests/day) - it became second nature to first understand where a failure is happening before trying to fix it.
I now work at Prophecy as an SRE II (one of the first 2 SREs we've hired) and we operate 30+ K8s clusters on GCP/AWS/Azure and have increased our fleet-wide uptime to 99% from ~85-90%.
Learning to understand what was happening "underneath" allowed me to get here.
A lesson I learned
Senior engineers aren't inherently smarter than others. They just know more about the types of failures that can occur.
This appears as some kind of innate "genius" when they come in to resolve an issue, but really they've just seen it many times before and know where to look.
You can cultivate this by intentionally exposing yourself to more failure scenarios (see below).
Underneath Thinking
As the name suggests, the goal of this habit is to understand what is happening underneath. When something fails, where is it failing and how do you know?
You can apply this by asking yourself:
What is the expected behaviour?
Where is the failure occurring?
What information do I have to identify that?
Only then should you begin thinking about what could cause the failure and how to resolve it.
This will appear to slow you down in the short term but will speed you up significantly once you've developed this thinking.
It'll also allow you to better utilise LLMs by giving them the context of where the failure is occurring and the information you have, rather than just dumping an error on them and expecting them to solve it.
And this is the skill that will become more and more valuable as more code is generated by LLMs - being able to understand what code that is running in production is doing and where it may fail.
Let's go through each step to help you develop this skill.
Developing the Underneath Habit
"Learning will come when your application breaks and you try to resolve it" - Me, some time ago.
That will be the case, but we don't want to rely on production systems failing for us to learn and become better engineers. So let's intentionally create those scenarios.
These steps are cumulative and you should do all of them to develop this habit. The first step only takes a few minutes, and by the final step you'll be able to demonstrate to a company in interviews why you're a good engineer.
1. Don't paste into an LLM / Google before reading the error + logs
When an issue occurs, take a few minutes to read the error message and identify the relevant logs that will contain more information about the failure.
This is more important than you'd think. In Sept 2025, IPinfo suffered a 2h36m outage due to a TLS certificate expiry. They found in their postmortem that their cert renewal job was failing, with errors in the logs - they simply weren't monitoring these.
Similar to how a doctor will ask you where you're experiencing pain and for how long, before running tests. You're identifying where it hurts.
For this week, next time something fails, attempt to identify where it failed and why. You don't need to be 100% correct, just develop the habit.
2. Identify one "underneath" question to learn about each day
Step 1 will train you when something fails. But you'll spend most of your time when things aren't failing. So let's build your intuition about what is happening "underneath" when things are working.
Each day, pick something you interact with and ask yourself what is happening underneath.
E.g. when I access a website:
My computer will query a DNS resolver to resolve the domain to an IP
My request will reach my server's load balancer/proxy
The load balancer/proxy will forward to my application
My application will respond to the request
At each stage something could fail, and I'd be able to identify which by looking at the relevant logs. E.g. if DNS failed to resolve, I'd see no requests reaching my server at all. If the TLS handshake failed, I'd see no requests reaching my application.
You're building up your intuition about what things look/sound like when working correctly.
Similar to how a car mechanic can identify an engine that's running incorrectly by hearing it, because they've listened to so many healthy engines.
Pick an "underneath" question to learn about each day (spend 10 mins researching) and continue doing so.
Some questions to learn about this week:
What does my computer use to resolve a domain to an IP?
What is the difference between a 404 and 502 error, and which part of the stack returns it?
When my container restarts, what happens?
3. Intentionally break something each week
Now that you have the foundation, we can start intentionally failing things. You can do this with your own VMs/homelab. Each week, break something.
Kill a process/service, configure a domain to point to an incorrect IP, create a TLS cert with an expiry of 1 day and revisit the next day, overfill disk space on your server etc.
Take time to observe how it failed and the errors you received and logs. Then, attempt to fix it for at least 30 minutes without referring to any tutorials before searching.
Allow yourself to struggle for a short period of time to learn from it.
Think of it as practising for a fire evacuation. You'll never know where to run if you only learn during a fire.
I did this organically when I ran my web hosting service. You get the benefit of doing this at your own leisure.
Repeat for the next 12 months and you'll have identified ~50 different ways systems can fail and how to identify where they're failing.
4. Use LLMs as your 2nd opinion
I'm not saying don't use LLMs. They are a great tool that will speed you up once you've identified where the failure is occurring and have the relevant information.
The key is what you paste in.
Weak context: "How do I fix a 502 error on my nginx server?"
Strong context: "My application is returning a 502 error to clients on path /api/orders since 18:00 today. I have checked the nginx logs and can see <error>. I know my app is up and running, but there doesn't seem to be anything listening on port 8080. I have tried X to no avail. What else could be preventing my app from listening on its port?"
You've given the LLM a much stronger starting point and will likely get a more useful response as a result. You should also be able to reason about whether the LLM's answer is likely to fix the problem or not.
Think of LLMs as a sat-nav - incredibly helpful but not infallible. It may direct you to drive off a cliff if you don't know any better.
This is how you can allay your fears about LLMs taking over your role - by knowing where your system can fail and identifying where it has failed.
5. Teach someone else
Finally, once you've resolved the issue, try to write 5 sentences explaining what you learnt and add to a document.
Expected behaviour
Where it failed
Information that allowed you to identify that
How you fixed it
What you'd do to identify the failure faster
This will help you identify the gaps in your knowledge. Just like if you were to teach a class on the topic and realised you couldn't confidently explain it to others.
It will also serve as a great reference for when an interviewer asks you about a failure you encountered and how you resolved it. I've been an interviewer and I've noticed that many candidates struggle with this question and give a generic response about some issue they've had. Having specific examples you can elaborate on will really set you apart.
Summary
When something fails, don't rush to Google/LLMs. Spend some time understanding the error and what logs will give you more info
Learn about one "underneath" question each day to understand what's happening when things are working
Break something on your own infrastructure each week and try to understand why it failed
Use LLMs as a second opinion, armed with the context of where the failure occurred and information you've gathered
Teach others about the failure you encountered and how you fixed it.
You'll quickly develop the habit of identifying where a failure is occurring, and what information to use to identify it.
With LLMs able to produce code/configs so quickly, being the engineer who understands why your system failed and how to fix it will be an invaluable skill.
Reply to this email and tell me about a recent failure you've experienced and where it was occurring. I may include some responses in a future issue (with credit).

Uptime Engineer
👋 Find me on Twitter | Linkedin | Connect 1:1
Thank you for supporting this newsletter.
Y’all are the best.
